diff options
Diffstat (limited to 'tests/unit_node')
105 files changed, 120729 insertions, 0 deletions
diff --git a/tests/unit_node/_fs/_fs_access_test.ts b/tests/unit_node/_fs/_fs_access_test.ts new file mode 100644 index 000000000..5b5b7f34d --- /dev/null +++ b/tests/unit_node/_fs/_fs_access_test.ts @@ -0,0 +1,67 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import * as fs from "node:fs"; +import { assertRejects, assertThrows } from "@test_util/std/assert/mod.ts"; + +Deno.test( + "[node/fs.access] Uses the owner permission when the user is the owner", + { ignore: Deno.build.os === "windows" }, + async () => { + const file = await Deno.makeTempFile(); + try { + await Deno.chmod(file, 0o600); + await fs.promises.access(file, fs.constants.R_OK); + await fs.promises.access(file, fs.constants.W_OK); + await assertRejects(async () => { + await fs.promises.access(file, fs.constants.X_OK); + }); + } finally { + await Deno.remove(file); + } + }, +); + +Deno.test( + "[node/fs.access] doesn't reject on windows", + { ignore: Deno.build.os !== "windows" }, + async () => { + const file = await Deno.makeTempFile(); + try { + await fs.promises.access(file, fs.constants.R_OK); + await fs.promises.access(file, fs.constants.W_OK); + } finally { + await Deno.remove(file); + } + }, +); + +Deno.test( + "[node/fs.accessSync] Uses the owner permission when the user is the owner", + { ignore: Deno.build.os === "windows" }, + () => { + const file = Deno.makeTempFileSync(); + try { + Deno.chmodSync(file, 0o600); + fs.accessSync(file, fs.constants.R_OK); + fs.accessSync(file, fs.constants.W_OK); + assertThrows(() => { + fs.accessSync(file, fs.constants.X_OK); + }); + } finally { + Deno.removeSync(file); + } + }, +); + +Deno.test( + "[node/fs.accessSync] doesn't throw on windows", + { ignore: Deno.build.os !== "windows" }, + () => { + const file = Deno.makeTempFileSync(); + try { + fs.accessSync(file, fs.constants.R_OK); + fs.accessSync(file, fs.constants.W_OK); + } finally { + Deno.removeSync(file); + } + }, +); diff --git a/tests/unit_node/_fs/_fs_appendFile_test.ts b/tests/unit_node/_fs/_fs_appendFile_test.ts new file mode 100644 index 000000000..57271efdb --- /dev/null +++ b/tests/unit_node/_fs/_fs_appendFile_test.ts @@ -0,0 +1,237 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { assertEquals, assertThrows, fail } from "@test_util/std/assert/mod.ts"; +import { appendFile, appendFileSync } from "node:fs"; +import { fromFileUrl } from "@test_util/std/path/mod.ts"; +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; + +const decoder = new TextDecoder("utf-8"); + +Deno.test({ + name: "No callback Fn results in Error", + fn() { + assertThrows( + () => { + // @ts-expect-error Argument of type 'string' is not assignable to parameter of type 'NoParamCallback' + appendFile("some/path", "some data", "utf8"); + }, + Error, + "The \"cb\" argument must be of type function. Received type string ('utf8')", + ); + }, +}); + +Deno.test({ + name: "Unsupported encoding results in error()", + fn() { + assertThrows( + () => { + // @ts-expect-error Type '"made-up-encoding"' is not assignable to type + appendFile("some/path", "some data", "made-up-encoding", () => {}); + }, + Error, + "The argument 'made-up-encoding' is invalid encoding. Received 'encoding'", + ); + assertThrows( + () => { + appendFile( + "some/path", + "some data", + // @ts-expect-error Type '"made-up-encoding"' is not assignable to type + { encoding: "made-up-encoding" }, + () => {}, + ); + }, + Error, + "The argument 'made-up-encoding' is invalid encoding. Received 'encoding'", + ); + assertThrows( + // @ts-expect-error Type '"made-up-encoding"' is not assignable to type + () => appendFileSync("some/path", "some data", "made-up-encoding"), + Error, + "The argument 'made-up-encoding' is invalid encoding. Received 'encoding'", + ); + assertThrows( + () => + appendFileSync("some/path", "some data", { + // @ts-expect-error Type '"made-up-encoding"' is not assignable to type + encoding: "made-up-encoding", + }), + Error, + "The argument 'made-up-encoding' is invalid encoding. Received 'encoding'", + ); + }, +}); + +Deno.test({ + name: "Async: Data is written to passed in rid", + async fn() { + const tempFile: string = await Deno.makeTempFile(); + using file = await Deno.open(tempFile, { + create: true, + write: true, + read: true, + }); + await new Promise<void>((resolve, reject) => { + appendFile(file.rid, "hello world", (err) => { + if (err) reject(); + else resolve(); + }); + }) + .then(async () => { + const data = await Deno.readFile(tempFile); + assertEquals(decoder.decode(data), "hello world"); + }, () => { + fail("No error expected"); + }) + .finally(async () => { + await Deno.remove(tempFile); + }); + }, +}); + +Deno.test({ + name: "Async: Data is written to passed in file path", + async fn() { + await new Promise<void>((resolve, reject) => { + appendFile("_fs_appendFile_test_file.txt", "hello world", (err) => { + if (err) reject(err); + else resolve(); + }); + }) + .then(async () => { + const data = await Deno.readFile("_fs_appendFile_test_file.txt"); + assertEquals(decoder.decode(data), "hello world"); + }, (err) => { + fail("No error was expected: " + err); + }) + .finally(async () => { + await Deno.remove("_fs_appendFile_test_file.txt"); + }); + }, +}); + +Deno.test({ + name: "Async: Data is written to passed in URL", + async fn() { + const fileURL = new URL("_fs_appendFile_test_file.txt", import.meta.url); + await new Promise<void>((resolve, reject) => { + appendFile(fileURL, "hello world", (err) => { + if (err) reject(err); + else resolve(); + }); + }) + .then(async () => { + const data = await Deno.readFile(fromFileUrl(fileURL)); + assertEquals(decoder.decode(data), "hello world"); + }, (err) => { + fail("No error was expected: " + err); + }) + .finally(async () => { + await Deno.remove(fromFileUrl(fileURL)); + }); + }, +}); + +Deno.test({ + name: + "Async: Callback is made with error if attempting to append data to an existing file with 'ax' flag", + async fn() { + const tempFile: string = await Deno.makeTempFile(); + await new Promise<void>((resolve, reject) => { + appendFile(tempFile, "hello world", { flag: "ax" }, (err) => { + if (err) reject(err); + else resolve(); + }); + }) + .then(() => fail("Expected error to be thrown")) + .catch(() => {}) + .finally(async () => { + await Deno.remove(tempFile); + }); + }, +}); + +Deno.test({ + name: "Sync: Data is written to passed in rid", + fn() { + const tempFile: string = Deno.makeTempFileSync(); + using file = Deno.openSync(tempFile, { + create: true, + write: true, + read: true, + }); + appendFileSync(file.rid, "hello world"); + const data = Deno.readFileSync(tempFile); + assertEquals(decoder.decode(data), "hello world"); + Deno.removeSync(tempFile); + }, +}); + +Deno.test({ + name: "Sync: Data is written to passed in file path", + fn() { + appendFileSync("_fs_appendFile_test_file_sync.txt", "hello world"); + const data = Deno.readFileSync("_fs_appendFile_test_file_sync.txt"); + assertEquals(decoder.decode(data), "hello world"); + Deno.removeSync("_fs_appendFile_test_file_sync.txt"); + }, +}); + +Deno.test({ + name: + "Sync: error thrown if attempting to append data to an existing file with 'ax' flag", + fn() { + const tempFile: string = Deno.makeTempFileSync(); + assertThrows( + () => appendFileSync(tempFile, "hello world", { flag: "ax" }), + Error, + "", + ); + Deno.removeSync(tempFile); + }, +}); + +Deno.test({ + name: "Sync: Data is written in Uint8Array to passed in file path", + fn() { + const testData = new TextEncoder().encode("hello world"); + appendFileSync("_fs_appendFile_test_file_sync.txt", testData); + const data = Deno.readFileSync("_fs_appendFile_test_file_sync.txt"); + assertEquals(data, testData); + Deno.removeSync("_fs_appendFile_test_file_sync.txt"); + }, +}); + +Deno.test({ + name: "Async: Data is written in Uint8Array to passed in file path", + async fn() { + const testData = new TextEncoder().encode("hello world"); + await new Promise<void>((resolve, reject) => { + appendFile("_fs_appendFile_test_file.txt", testData, (err) => { + if (err) reject(err); + else resolve(); + }); + }) + .then(async () => { + const data = await Deno.readFile("_fs_appendFile_test_file.txt"); + assertEquals(data, testData); + }, (err) => { + fail("No error was expected: " + err); + }) + .finally(async () => { + await Deno.remove("_fs_appendFile_test_file.txt"); + }); + }, +}); + +Deno.test("[std/node/fs] appendFile callback isn't called twice if error is thrown", async () => { + const tempFile = await Deno.makeTempFile(); + const importUrl = new URL("node:fs", import.meta.url); + await assertCallbackErrorUncaught({ + prelude: `import { appendFile } from ${JSON.stringify(importUrl)}`, + invocation: `appendFile(${JSON.stringify(tempFile)}, "hello world", `, + async cleanup() { + await Deno.remove(tempFile); + }, + }); +}); diff --git a/tests/unit_node/_fs/_fs_chmod_test.ts b/tests/unit_node/_fs/_fs_chmod_test.ts new file mode 100644 index 000000000..2bddcb293 --- /dev/null +++ b/tests/unit_node/_fs/_fs_chmod_test.ts @@ -0,0 +1,121 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { + assert, + assertRejects, + assertThrows, + fail, +} from "@test_util/std/assert/mod.ts"; +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; +import { chmod, chmodSync } from "node:fs"; + +Deno.test({ + name: "ASYNC: Permissions are changed (non-Windows)", + ignore: Deno.build.os === "windows", + async fn() { + const tempFile: string = await Deno.makeTempFile(); + const originalFileMode: number | null = (await Deno.lstat(tempFile)).mode; + await new Promise<void>((resolve, reject) => { + chmod(tempFile, 0o777, (err) => { + if (err) reject(err); + else resolve(); + }); + }) + .then(() => { + const newFileMode: number | null = Deno.lstatSync(tempFile).mode; + assert(newFileMode && originalFileMode); + assert(newFileMode === 33279 && newFileMode > originalFileMode); + }, (error) => { + fail(error); + }) + .finally(() => { + Deno.removeSync(tempFile); + }); + }, +}); + +Deno.test({ + name: "ASYNC: don't throw NotSupportedError (Windows)", + ignore: Deno.build.os !== "windows", + async fn() { + const tempFile: string = await Deno.makeTempFile(); + await new Promise<void>((resolve, reject) => { + chmod(tempFile, 0o777, (err) => { + if (err) reject(err); + else resolve(); + }); + }).finally(() => { + Deno.removeSync(tempFile); + }); + }, +}); + +Deno.test({ + name: "ASYNC: don't swallow NotFoundError (Windows)", + ignore: Deno.build.os !== "windows", + async fn() { + await assertRejects(async () => { + await new Promise<void>((resolve, reject) => { + chmod("./__non_existent_file__", 0o777, (err) => { + if (err) reject(err); + else resolve(); + }); + }); + }); + }, +}); + +Deno.test({ + name: "SYNC: Permissions are changed (non-Windows)", + ignore: Deno.build.os === "windows", + fn() { + const tempFile: string = Deno.makeTempFileSync(); + try { + const originalFileMode: number | null = Deno.lstatSync(tempFile).mode; + chmodSync(tempFile, "777"); + + const newFileMode: number | null = Deno.lstatSync(tempFile).mode; + assert(newFileMode && originalFileMode); + assert(newFileMode === 33279 && newFileMode > originalFileMode); + } finally { + Deno.removeSync(tempFile); + } + }, +}); + +Deno.test({ + name: "SYNC: don't throw NotSupportedError (Windows)", + ignore: Deno.build.os !== "windows", + fn() { + const tempFile: string = Deno.makeTempFileSync(); + try { + chmodSync(tempFile, "777"); + } finally { + Deno.removeSync(tempFile); + } + }, +}); + +Deno.test({ + name: "SYNC: don't swallow NotFoundError (Windows)", + ignore: Deno.build.os !== "windows", + fn() { + assertThrows(() => { + chmodSync("./__non_existent_file__", "777"); + }); + }, +}); + +Deno.test({ + name: "[std/node/fs] chmod callback isn't called twice if error is thrown", + async fn() { + const tempFile = await Deno.makeTempFile(); + const importUrl = new URL("node:fs", import.meta.url); + await assertCallbackErrorUncaught({ + prelude: `import { chmod } from ${JSON.stringify(importUrl)}`, + invocation: `chmod(${JSON.stringify(tempFile)}, 0o777, `, + async cleanup() { + await Deno.remove(tempFile); + }, + }); + }, +}); diff --git a/tests/unit_node/_fs/_fs_chown_test.ts b/tests/unit_node/_fs/_fs_chown_test.ts new file mode 100644 index 000000000..d4f6ea0e8 --- /dev/null +++ b/tests/unit_node/_fs/_fs_chown_test.ts @@ -0,0 +1,69 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { assertEquals, fail } from "@test_util/std/assert/mod.ts"; +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; +import { chown, chownSync } from "node:fs"; + +// chown is difficult to test. Best we can do is set the existing user id/group +// id again +const ignore = Deno.build.os === "windows"; + +Deno.test({ + ignore, + name: "ASYNC: setting existing uid/gid works as expected (non-Windows)", + async fn() { + const tempFile: string = await Deno.makeTempFile(); + const originalUserId: number | null = (await Deno.lstat(tempFile)).uid; + const originalGroupId: number | null = (await Deno.lstat(tempFile)).gid; + await new Promise<void>((resolve, reject) => { + chown(tempFile, originalUserId!, originalGroupId!, (err) => { + if (err) reject(err); + else resolve(); + }); + }) + .then(() => { + const newUserId: number | null = Deno.lstatSync(tempFile).uid; + const newGroupId: number | null = Deno.lstatSync(tempFile).gid; + assertEquals(newUserId, originalUserId); + assertEquals(newGroupId, originalGroupId); + }, () => { + fail(); + }) + .finally(() => { + Deno.removeSync(tempFile); + }); + }, +}); + +Deno.test({ + ignore, + name: "SYNC: setting existing uid/gid works as expected (non-Windows)", + fn() { + const tempFile: string = Deno.makeTempFileSync(); + const originalUserId: number | null = Deno.lstatSync(tempFile).uid; + const originalGroupId: number | null = Deno.lstatSync(tempFile).gid; + chownSync(tempFile, originalUserId!, originalGroupId!); + + const newUserId: number | null = Deno.lstatSync(tempFile).uid; + const newGroupId: number | null = Deno.lstatSync(tempFile).gid; + assertEquals(newUserId, originalUserId); + assertEquals(newGroupId, originalGroupId); + Deno.removeSync(tempFile); + }, +}); + +Deno.test({ + name: "[std/node/fs] chown callback isn't called twice if error is thrown", + ignore: Deno.build.os === "windows", + async fn() { + const tempFile = await Deno.makeTempFile(); + const { uid, gid } = await Deno.lstat(tempFile); + const importUrl = new URL("node:fs", import.meta.url); + await assertCallbackErrorUncaught({ + prelude: `import { chown } from ${JSON.stringify(importUrl)}`, + invocation: `chown(${JSON.stringify(tempFile)}, ${uid}, ${gid}, `, + async cleanup() { + await Deno.remove(tempFile); + }, + }); + }, +}); diff --git a/tests/unit_node/_fs/_fs_close_test.ts b/tests/unit_node/_fs/_fs_close_test.ts new file mode 100644 index 000000000..155667305 --- /dev/null +++ b/tests/unit_node/_fs/_fs_close_test.ts @@ -0,0 +1,86 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { assert, assertThrows, fail } from "@test_util/std/assert/mod.ts"; +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; +import { close, closeSync } from "node:fs"; + +Deno.test({ + name: "ASYNC: File is closed", + async fn() { + const tempFile: string = await Deno.makeTempFile(); + const file: Deno.FsFile = await Deno.open(tempFile); + + await new Promise<void>((resolve, reject) => { + close(file.rid, (err) => { + if (err !== null) reject(); + else resolve(); + }); + }) + .catch(() => fail("No error expected")) + .finally(async () => { + await Deno.remove(tempFile); + }); + }, +}); + +Deno.test({ + name: "ASYNC: Invalid fd", + fn() { + assertThrows(() => { + close(-1, (_err) => {}); + }, RangeError); + }, +}); + +Deno.test({ + name: "close callback should be asynchronous", + async fn() { + const tempFile: string = Deno.makeTempFileSync(); + const file: Deno.FsFile = Deno.openSync(tempFile); + + let foo: string; + const promise = new Promise<void>((resolve) => { + close(file.rid, () => { + assert(foo === "bar"); + resolve(); + }); + foo = "bar"; + }); + + await promise; + Deno.removeSync(tempFile); + }, +}); + +Deno.test({ + name: "SYNC: File is closed", + fn() { + const tempFile: string = Deno.makeTempFileSync(); + const file: Deno.FsFile = Deno.openSync(tempFile); + + closeSync(file.rid); + Deno.removeSync(tempFile); + }, +}); + +Deno.test({ + name: "SYNC: Invalid fd", + fn() { + assertThrows(() => closeSync(-1)); + }, +}); + +Deno.test("[std/node/fs] close callback isn't called twice if error is thrown", async () => { + const tempFile = await Deno.makeTempFile(); + const importUrl = new URL("node:fs", import.meta.url); + await assertCallbackErrorUncaught({ + prelude: ` + import { close } from ${JSON.stringify(importUrl)}; + + const file = await Deno.open(${JSON.stringify(tempFile)}); + `, + invocation: "close(file.rid, ", + async cleanup() { + await Deno.remove(tempFile); + }, + }); +}); diff --git a/tests/unit_node/_fs/_fs_copy_test.ts b/tests/unit_node/_fs/_fs_copy_test.ts new file mode 100644 index 000000000..915ee93bd --- /dev/null +++ b/tests/unit_node/_fs/_fs_copy_test.ts @@ -0,0 +1,52 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import * as path from "@test_util/std/path/mod.ts"; +import { assert } from "@test_util/std/assert/mod.ts"; +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; +import { copyFile, copyFileSync, existsSync } from "node:fs"; + +const destFile = "./destination.txt"; + +Deno.test({ + name: "[std/node/fs] copy file", + fn: async () => { + const sourceFile = Deno.makeTempFileSync(); + const err = await new Promise((resolve) => { + copyFile(sourceFile, destFile, (err?: Error | null) => resolve(err)); + }); + assert(!err); + assert(existsSync(destFile)); + Deno.removeSync(sourceFile); + Deno.removeSync(destFile); + }, +}); + +Deno.test({ + name: "[std/node/fs] copy file sync", + fn: () => { + const sourceFile = Deno.makeTempFileSync(); + copyFileSync(sourceFile, destFile); + assert(existsSync(destFile)); + Deno.removeSync(sourceFile); + Deno.removeSync(destFile); + }, +}); + +Deno.test("[std/node/fs] copyFile callback isn't called twice if error is thrown", async () => { + // The correct behaviour is not to catch any errors thrown, + // but that means there'll be an uncaught error and the test will fail. + // So the only way to test this is to spawn a subprocess, and succeed if it has a non-zero exit code. + // (assertRejects won't work because there's no way to catch the error.) + const tempDir = await Deno.makeTempDir(); + const tempFile1 = path.join(tempDir, "file1.txt"); + const tempFile2 = path.join(tempDir, "file2.txt"); + await Deno.writeTextFile(tempFile1, "hello world"); + const importUrl = new URL("node:fs", import.meta.url); + await assertCallbackErrorUncaught({ + prelude: `import { copyFile } from ${JSON.stringify(importUrl)}`, + invocation: `copyFile(${JSON.stringify(tempFile1)}, + ${JSON.stringify(tempFile2)}, `, + async cleanup() { + await Deno.remove(tempDir, { recursive: true }); + }, + }); +}); diff --git a/tests/unit_node/_fs/_fs_dir_test.ts b/tests/unit_node/_fs/_fs_dir_test.ts new file mode 100644 index 000000000..697929fee --- /dev/null +++ b/tests/unit_node/_fs/_fs_dir_test.ts @@ -0,0 +1,205 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { assert, assertEquals, fail } from "@test_util/std/assert/mod.ts"; +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; +import { Dir as DirOrig, type Dirent } from "node:fs"; + +// deno-lint-ignore no-explicit-any +const Dir = DirOrig as any; + +Deno.test({ + name: "Closing current directory with callback is successful", + fn() { + let calledBack = false; + // deno-lint-ignore no-explicit-any + new Dir(".").close((valOrErr: any) => { + assert(!valOrErr); + calledBack = true; + }); + assert(calledBack); + }, +}); + +Deno.test({ + name: "Closing current directory without callback returns void Promise", + async fn() { + await new Dir(".").close(); + }, +}); + +Deno.test({ + name: "Closing current directory synchronously works", + fn() { + new Dir(".").closeSync(); + }, +}); + +Deno.test({ + name: "Path is correctly returned", + fn() { + assertEquals(new Dir("std/node").path, "std/node"); + + const enc: Uint8Array = new TextEncoder().encode("std/node"); + assertEquals(new Dir(enc).path, "std/node"); + }, +}); + +Deno.test({ + name: "read returns null for empty directory", + async fn() { + const testDir: string = Deno.makeTempDirSync(); + try { + const file: Dirent | null = await new Dir(testDir).read(); + assert(file === null); + + let calledBack = false; + const fileFromCallback: Dirent | null = await new Dir( + testDir, + // deno-lint-ignore no-explicit-any + ).read((err: any, res: Dirent) => { + assert(res === null); + assert(err === null); + calledBack = true; + }); + assert(fileFromCallback === null); + assert(calledBack); + + assertEquals(new Dir(testDir).readSync(), null); + } finally { + Deno.removeSync(testDir); + } + }, +}); + +Deno.test({ + name: "Async read returns one file at a time", + async fn() { + const testDir: string = Deno.makeTempDirSync(); + const f1 = Deno.createSync(testDir + "/foo.txt"); + f1.close(); + const f2 = Deno.createSync(testDir + "/bar.txt"); + f2.close(); + + try { + let secondCallback = false; + const dir = new Dir(testDir); + const firstRead: Dirent | null = await dir.read(); + const secondRead: Dirent | null = await dir.read( + // deno-lint-ignore no-explicit-any + (_err: any, secondResult: Dirent) => { + assert( + secondResult.name === "bar.txt" || secondResult.name === "foo.txt", + ); + secondCallback = true; + }, + ); + const thirdRead: Dirent | null = await dir.read(); + const fourthRead: Dirent | null = await dir.read(); + + if (firstRead?.name === "foo.txt") { + assertEquals(secondRead?.name, "bar.txt"); + } else if (firstRead?.name === "bar.txt") { + assertEquals(secondRead?.name, "foo.txt"); + } else { + fail("File not found during read"); + } + assert(secondCallback); + assert(thirdRead === null); + assert(fourthRead === null); + } finally { + Deno.removeSync(testDir, { recursive: true }); + } + }, +}); + +Deno.test({ + name: "Sync read returns one file at a time", + fn() { + const testDir: string = Deno.makeTempDirSync(); + const f1 = Deno.createSync(testDir + "/foo.txt"); + f1.close(); + const f2 = Deno.createSync(testDir + "/bar.txt"); + f2.close(); + + try { + const dir = new Dir(testDir); + const firstRead: Dirent | null = dir.readSync(); + const secondRead: Dirent | null = dir.readSync(); + const thirdRead: Dirent | null = dir.readSync(); + const fourthRead: Dirent | null = dir.readSync(); + + if (firstRead?.name === "foo.txt") { + assertEquals(secondRead?.name, "bar.txt"); + } else if (firstRead?.name === "bar.txt") { + assertEquals(secondRead?.name, "foo.txt"); + } else { + fail("File not found during read"); + } + assert(thirdRead === null); + assert(fourthRead === null); + } finally { + Deno.removeSync(testDir, { recursive: true }); + } + }, +}); + +Deno.test({ + name: "Async iteration over existing directory", + async fn() { + const testDir: string = Deno.makeTempDirSync(); + const f1 = Deno.createSync(testDir + "/foo.txt"); + f1.close(); + const f2 = Deno.createSync(testDir + "/bar.txt"); + f2.close(); + + try { + const dir = new Dir(testDir); + const results: Array<string | null> = []; + + for await (const file of dir[Symbol.asyncIterator]()) { + results.push(file.name); + } + + assert(results.length === 2); + assert(results.includes("foo.txt")); + assert(results.includes("bar.txt")); + } finally { + Deno.removeSync(testDir, { recursive: true }); + } + }, +}); + +Deno.test( + "[std/node/fs] Dir.close callback isn't called twice if error is thrown", + async () => { + const tempDir = await Deno.makeTempDir(); + await assertCallbackErrorUncaught({ + prelude: ` + import { Dir } from "node:fs"; + + const dir = new Dir(${JSON.stringify(tempDir)}); + `, + invocation: "dir.close(", + async cleanup() { + await Deno.remove(tempDir); + }, + }); + }, +); + +Deno.test( + "[std/node/fs] Dir.read callback isn't called twice if error is thrown", + async () => { + const tempDir = await Deno.makeTempDir(); + await assertCallbackErrorUncaught({ + prelude: ` + import { Dir } from "node:fs"; + + const dir = new Dir(${JSON.stringify(tempDir)}); + `, + invocation: "dir.read(", + async cleanup() { + await Deno.remove(tempDir); + }, + }); + }, +); diff --git a/tests/unit_node/_fs/_fs_dirent_test.ts b/tests/unit_node/_fs/_fs_dirent_test.ts new file mode 100644 index 000000000..a42f6a25c --- /dev/null +++ b/tests/unit_node/_fs/_fs_dirent_test.ts @@ -0,0 +1,86 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { + assert, + assertEquals, + assertThrows, +} from "@test_util/std/assert/mod.ts"; +import { Dirent as Dirent_ } from "node:fs"; + +// deno-lint-ignore no-explicit-any +const Dirent = Dirent_ as any; + +class DirEntryMock implements Deno.DirEntry { + name = ""; + isFile = false; + isDirectory = false; + isSymlink = false; +} + +Deno.test({ + name: "Directories are correctly identified", + fn() { + const entry: DirEntryMock = new DirEntryMock(); + entry.isDirectory = true; + entry.isFile = false; + entry.isSymlink = false; + assert(new Dirent(entry).isDirectory()); + assert(!new Dirent(entry).isFile()); + assert(!new Dirent(entry).isSymbolicLink()); + }, +}); + +Deno.test({ + name: "Files are correctly identified", + fn() { + const entry: DirEntryMock = new DirEntryMock(); + entry.isDirectory = false; + entry.isFile = true; + entry.isSymlink = false; + assert(!new Dirent(entry).isDirectory()); + assert(new Dirent(entry).isFile()); + assert(!new Dirent(entry).isSymbolicLink()); + }, +}); + +Deno.test({ + name: "Symlinks are correctly identified", + fn() { + const entry: DirEntryMock = new DirEntryMock(); + entry.isDirectory = false; + entry.isFile = false; + entry.isSymlink = true; + assert(!new Dirent(entry).isDirectory()); + assert(!new Dirent(entry).isFile()); + assert(new Dirent(entry).isSymbolicLink()); + }, +}); + +Deno.test({ + name: "File name is correct", + fn() { + const entry: DirEntryMock = new DirEntryMock(); + entry.name = "my_file"; + assertEquals(new Dirent(entry).name, "my_file"); + }, +}); + +Deno.test({ + name: "Socket and FIFO pipes aren't yet available", + fn() { + const entry: DirEntryMock = new DirEntryMock(); + assertThrows( + () => { + new Dirent(entry).isFIFO(); + }, + Error, + "does not yet support", + ); + assertThrows( + () => { + new Dirent(entry).isSocket(); + }, + Error, + "does not yet support", + ); + }, +}); diff --git a/tests/unit_node/_fs/_fs_exists_test.ts b/tests/unit_node/_fs/_fs_exists_test.ts new file mode 100644 index 000000000..baf959502 --- /dev/null +++ b/tests/unit_node/_fs/_fs_exists_test.ts @@ -0,0 +1,65 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { + assert, + assertEquals, + assertStringIncludes, +} from "@test_util/std/assert/mod.ts"; +import { exists, existsSync } from "node:fs"; +import { promisify } from "node:util"; + +Deno.test("[std/node/fs] exists", async function () { + const availableFile = await new Promise((resolve) => { + const tmpFilePath = Deno.makeTempFileSync(); + exists(tmpFilePath, (exists: boolean) => { + Deno.removeSync(tmpFilePath); + resolve(exists); + }); + }); + const notAvailableFile = await new Promise((resolve) => { + exists("./notAvailable.txt", (exists: boolean) => resolve(exists)); + }); + assertEquals(availableFile, true); + assertEquals(notAvailableFile, false); +}); + +Deno.test("[std/node/fs] existsSync", function () { + const tmpFilePath = Deno.makeTempFileSync(); + assertEquals(existsSync(tmpFilePath), true); + Deno.removeSync(tmpFilePath); + assertEquals(existsSync("./notAvailable.txt"), false); +}); + +Deno.test("[std/node/fs] promisify(exists)", async () => { + const tmpFilePath = await Deno.makeTempFile(); + try { + const existsPromisified = promisify(exists); + assert(await existsPromisified(tmpFilePath)); + assert(!await existsPromisified("./notAvailable.txt")); + } finally { + await Deno.remove(tmpFilePath); + } +}); + +Deno.test("[std/node/fs] exists callback isn't called twice if error is thrown", async () => { + // This doesn't use `assertCallbackErrorUncaught()` because `exists()` doesn't return a standard node callback, which is what it expects. + const tempFile = await Deno.makeTempFile(); + const importUrl = new URL("node:fs", import.meta.url); + const command = new Deno.Command(Deno.execPath(), { + args: [ + "eval", + "--no-check", + ` + import { exists } from ${JSON.stringify(importUrl)}; + + exists(${JSON.stringify(tempFile)}, (exists) => { + // If the bug is present and the callback is called again with false (meaning an error occurred), + // don't throw another error, so if the subprocess fails we know it had the correct behaviour. + if (exists) throw new Error("success"); + });`, + ], + }); + const { success, stderr } = await command.output(); + await Deno.remove(tempFile); + assert(!success); + assertStringIncludes(new TextDecoder().decode(stderr), "Error: success"); +}); diff --git a/tests/unit_node/_fs/_fs_fdatasync_test.ts b/tests/unit_node/_fs/_fs_fdatasync_test.ts new file mode 100644 index 000000000..7a61bd4c1 --- /dev/null +++ b/tests/unit_node/_fs/_fs_fdatasync_test.ts @@ -0,0 +1,58 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { assertEquals, fail } from "@test_util/std/assert/mod.ts"; +import { fdatasync, fdatasyncSync } from "node:fs"; + +Deno.test({ + name: + "ASYNC: flush any pending data operations of the given file stream to disk", + async fn() { + const filePath = await Deno.makeTempFile(); + using file = await Deno.open(filePath, { + read: true, + write: true, + create: true, + }); + const data = new Uint8Array(64); + await file.write(data); + + await new Promise<void>((resolve, reject) => { + fdatasync(file.rid, (err: Error | null) => { + if (err !== null) reject(); + else resolve(); + }); + }) + .then( + async () => { + assertEquals(await Deno.readFile(filePath), data); + }, + () => { + fail("No error expected"); + }, + ) + .finally(async () => { + await Deno.remove(filePath); + }); + }, +}); + +Deno.test({ + name: + "SYNC: flush any pending data operations of the given file stream to disk.", + fn() { + const filePath = Deno.makeTempFileSync(); + using file = Deno.openSync(filePath, { + read: true, + write: true, + create: true, + }); + const data = new Uint8Array(64); + Deno.writeSync(file.rid, data); + + try { + fdatasyncSync(file.rid); + assertEquals(Deno.readFileSync(filePath), data); + } finally { + Deno.removeSync(filePath); + } + }, +}); diff --git a/tests/unit_node/_fs/_fs_fstat_test.ts b/tests/unit_node/_fs/_fs_fstat_test.ts new file mode 100644 index 000000000..d15ef5a80 --- /dev/null +++ b/tests/unit_node/_fs/_fs_fstat_test.ts @@ -0,0 +1,90 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { fstat, fstatSync } from "node:fs"; +import { fail } from "@test_util/std/assert/mod.ts"; +import { assertStats, assertStatsBigInt } from "./_fs_stat_test.ts"; +import type { BigIntStats, Stats } from "node:fs"; + +Deno.test({ + name: "ASYNC: get a file Stats", + async fn() { + const filePath = await Deno.makeTempFile(); + using file = await Deno.open(filePath); + + await new Promise<Stats>((resolve, reject) => { + fstat(file.rid, (err: Error | null, stat: Stats) => { + if (err) reject(err); + resolve(stat); + }); + }) + .then( + (stat) => { + assertStats(stat, file.statSync()); + }, + () => fail(), + ) + .finally(() => { + Deno.removeSync(filePath); + }); + }, +}); + +Deno.test({ + name: "ASYNC: get a file BigInt Stats", + async fn() { + const filePath = await Deno.makeTempFile(); + using file = await Deno.open(filePath); + + await new Promise<BigIntStats>((resolve, reject) => { + fstat( + file.rid, + { bigint: true }, + (err: Error | null, stat: BigIntStats) => { + if (err) reject(err); + resolve(stat); + }, + ); + }) + .then( + (stat) => assertStatsBigInt(stat, file.statSync()), + () => fail(), + ) + .finally(() => { + Deno.removeSync(filePath); + }); + }, +}); + +Deno.test({ + name: "SYNC: get a file Stats", + fn() { + const filePath = Deno.makeTempFileSync(); + using file = Deno.openSync(filePath); + + try { + assertStats(fstatSync(file.rid), file.statSync()); + } finally { + Deno.removeSync(filePath); + } + }, +}); + +Deno.test({ + name: "SYNC: get a file BigInt Stats", + fn() { + const filePath = Deno.makeTempFileSync(); + using file = Deno.openSync(filePath); + + try { + // HEAD + assertStatsBigInt(fstatSync(file.rid, { bigint: true }), file.statSync()); + // + assertStatsBigInt( + fstatSync(file.rid, { bigint: true }), + Deno.fstatSync(file.rid), + ); + //main + } finally { + Deno.removeSync(filePath); + } + }, +}); diff --git a/tests/unit_node/_fs/_fs_fsync_test.ts b/tests/unit_node/_fs/_fs_fsync_test.ts new file mode 100644 index 000000000..870055c00 --- /dev/null +++ b/tests/unit_node/_fs/_fs_fsync_test.ts @@ -0,0 +1,56 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { assertEquals, fail } from "@test_util/std/assert/mod.ts"; +import { fsync, fsyncSync } from "node:fs"; + +Deno.test({ + name: "ASYNC: flush any pending data of the given file stream to disk", + async fn() { + const filePath = await Deno.makeTempFile(); + using file = await Deno.open(filePath, { + read: true, + write: true, + create: true, + }); + const size = 64; + await file.truncate(size); + + await new Promise<void>((resolve, reject) => { + fsync(file.rid, (err: Error | null) => { + if (err !== null) reject(); + else resolve(); + }); + }) + .then( + async () => { + assertEquals((await Deno.stat(filePath)).size, size); + }, + () => { + fail("No error expected"); + }, + ) + .finally(async () => { + await Deno.remove(filePath); + }); + }, +}); + +Deno.test({ + name: "SYNC: flush any pending data the given file stream to disk", + fn() { + const filePath = Deno.makeTempFileSync(); + using file = Deno.openSync(filePath, { + read: true, + write: true, + create: true, + }); + const size = 64; + file.truncateSync(size); + + try { + fsyncSync(file.rid); + assertEquals(Deno.statSync(filePath).size, size); + } finally { + Deno.removeSync(filePath); + } + }, +}); diff --git a/tests/unit_node/_fs/_fs_ftruncate_test.ts b/tests/unit_node/_fs/_fs_ftruncate_test.ts new file mode 100644 index 000000000..1e669fb60 --- /dev/null +++ b/tests/unit_node/_fs/_fs_ftruncate_test.ts @@ -0,0 +1,123 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { assertEquals, assertThrows, fail } from "@test_util/std/assert/mod.ts"; +import { ftruncate, ftruncateSync } from "node:fs"; + +Deno.test({ + name: "ASYNC: no callback function results in Error", + fn() { + assertThrows( + () => { + // @ts-expect-error Argument of type 'number' is not assignable to parameter of type 'NoParamCallback' + ftruncate(123, 0); + }, + Error, + "No callback function supplied", + ); + }, +}); + +Deno.test({ + name: "ASYNC: truncate entire file contents", + async fn() { + const filePath = Deno.makeTempFileSync(); + await Deno.writeTextFile(filePath, "hello world"); + using file = await Deno.open(filePath, { + read: true, + write: true, + create: true, + }); + + await new Promise<void>((resolve, reject) => { + ftruncate(file.rid, (err: Error | null) => { + if (err !== null) reject(); + else resolve(); + }); + }) + .then( + () => { + const fileInfo: Deno.FileInfo = Deno.lstatSync(filePath); + assertEquals(fileInfo.size, 0); + }, + () => { + fail("No error expected"); + }, + ) + .finally(() => { + Deno.removeSync(filePath); + }); + }, +}); + +Deno.test({ + name: "ASYNC: truncate file to a size of precisely len bytes", + async fn() { + const filePath = Deno.makeTempFileSync(); + await Deno.writeTextFile(filePath, "hello world"); + using file = await Deno.open(filePath, { + read: true, + write: true, + create: true, + }); + + await new Promise<void>((resolve, reject) => { + ftruncate(file.rid, 3, (err: Error | null) => { + if (err !== null) reject(); + else resolve(); + }); + }) + .then( + () => { + const fileInfo: Deno.FileInfo = Deno.lstatSync(filePath); + assertEquals(fileInfo.size, 3); + }, + () => { + fail("No error expected"); + }, + ) + .finally(() => { + Deno.removeSync(filePath); + }); + }, +}); + +Deno.test({ + name: "SYNC: truncate entire file contents", + fn() { + const filePath = Deno.makeTempFileSync(); + Deno.writeFileSync(filePath, new TextEncoder().encode("hello world")); + using file = Deno.openSync(filePath, { + read: true, + write: true, + create: true, + }); + + try { + ftruncateSync(file.rid); + const fileInfo: Deno.FileInfo = Deno.lstatSync(filePath); + assertEquals(fileInfo.size, 0); + } finally { + Deno.removeSync(filePath); + } + }, +}); + +Deno.test({ + name: "SYNC: truncate file to a size of precisely len bytes", + fn() { + const filePath = Deno.makeTempFileSync(); + Deno.writeFileSync(filePath, new TextEncoder().encode("hello world")); + using file = Deno.openSync(filePath, { + read: true, + write: true, + create: true, + }); + + try { + ftruncateSync(file.rid, 3); + const fileInfo: Deno.FileInfo = Deno.lstatSync(filePath); + assertEquals(fileInfo.size, 3); + } finally { + Deno.removeSync(filePath); + } + }, +}); diff --git a/tests/unit_node/_fs/_fs_futimes_test.ts b/tests/unit_node/_fs/_fs_futimes_test.ts new file mode 100644 index 000000000..bf3746957 --- /dev/null +++ b/tests/unit_node/_fs/_fs_futimes_test.ts @@ -0,0 +1,106 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { assertEquals, assertThrows, fail } from "@test_util/std/assert/mod.ts"; +import { futimes, futimesSync } from "node:fs"; + +const randomDate = new Date(Date.now() + 1000); + +Deno.test({ + name: + "ASYNC: change the file system timestamps of the object referenced by path", + async fn() { + const filePath = Deno.makeTempFileSync(); + using file = await Deno.open(filePath, { create: true, write: true }); + + await new Promise<void>((resolve, reject) => { + futimes(file.rid, randomDate, randomDate, (err: Error | null) => { + if (err !== null) reject(); + else resolve(); + }); + }) + .then( + () => { + const fileInfo: Deno.FileInfo = Deno.lstatSync(filePath); + assertEquals(fileInfo.mtime, randomDate); + assertEquals(fileInfo.atime, randomDate); + }, + () => { + fail("No error expected"); + }, + ) + .finally(() => { + Deno.removeSync(filePath); + }); + }, +}); + +Deno.test({ + name: "ASYNC: should throw error if atime is infinity", + fn() { + assertThrows( + () => { + futimes(123, Infinity, 0, (_err: Error | null) => {}); + }, + Error, + "invalid atime, must not be infinity or NaN", + ); + }, +}); + +Deno.test({ + name: "ASYNC: should throw error if atime is NaN", + fn() { + assertThrows( + () => { + futimes(123, "some string", 0, (_err: Error | null) => {}); + }, + Error, + "invalid atime, must not be infinity or NaN", + ); + }, +}); + +Deno.test({ + name: + "SYNC: change the file system timestamps of the object referenced by path", + fn() { + const filePath = Deno.makeTempFileSync(); + using file = Deno.openSync(filePath, { create: true, write: true }); + + try { + futimesSync(file.rid, randomDate, randomDate); + + const fileInfo: Deno.FileInfo = Deno.lstatSync(filePath); + + assertEquals(fileInfo.mtime, randomDate); + assertEquals(fileInfo.atime, randomDate); + } finally { + Deno.removeSync(filePath); + } + }, +}); + +Deno.test({ + name: "SYNC: should throw error if atime is NaN", + fn() { + assertThrows( + () => { + futimesSync(123, "some string", 0); + }, + Error, + "invalid atime, must not be infinity or NaN", + ); + }, +}); + +Deno.test({ + name: "SYNC: should throw error if atime is Infinity", + fn() { + assertThrows( + () => { + futimesSync(123, Infinity, 0); + }, + Error, + "invalid atime, must not be infinity or NaN", + ); + }, +}); diff --git a/tests/unit_node/_fs/_fs_handle_test.ts b/tests/unit_node/_fs/_fs_handle_test.ts new file mode 100644 index 000000000..151d4d752 --- /dev/null +++ b/tests/unit_node/_fs/_fs_handle_test.ts @@ -0,0 +1,88 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import * as path from "@test_util/std/path/mod.ts"; +import { Buffer } from "node:buffer"; +import * as fs from "node:fs/promises"; +import { assert, assertEquals } from "@test_util/std/assert/mod.ts"; + +const moduleDir = path.dirname(path.fromFileUrl(import.meta.url)); +const testData = path.resolve(moduleDir, "testdata", "hello.txt"); +const decoder = new TextDecoder(); + +Deno.test("readFileSuccess", async function () { + const fileHandle = await fs.open(testData); + const data = await fileHandle.readFile(); + + assert(data instanceof Uint8Array); + assertEquals(decoder.decode(data as Uint8Array), "hello world"); + + await fileHandle.close(); +}); + +Deno.test("read", async function () { + const fileHandle = await fs.open(testData); + const byteLength = "hello world".length; + + const buf = new Buffer(byteLength); + await fileHandle.read(buf, 0, byteLength, 0); + + assertEquals(decoder.decode(buf as Uint8Array), "hello world"); + + await fileHandle.close(); +}); + +Deno.test("read specify opt", async function () { + const fileHandle = await fs.open(testData); + const byteLength = "hello world".length; + + const opt = { + buffer: new Buffer(byteLength), + offset: 6, + length: 5, + }; + let res = await fileHandle.read(opt); + + assertEquals(res.bytesRead, byteLength); + assertEquals(new TextDecoder().decode(res.buffer as Uint8Array), "world"); + + const opt2 = { + buffer: new Buffer(byteLength), + length: 5, + position: 0, + }; + res = await fileHandle.read(opt2); + + assertEquals(res.bytesRead, byteLength); + assertEquals(decoder.decode(res.buffer as Uint8Array), "hello"); + + await fileHandle.close(); +}); + +Deno.test("[node/fs filehandle.write] Write from Buffer", async function () { + const tempFile: string = await Deno.makeTempFile(); + const fileHandle = await fs.open(tempFile, "a+"); + + const buffer = Buffer.from("hello world"); + const res = await fileHandle.write(buffer, 0, 5, 0); + + const data = Deno.readFileSync(tempFile); + await Deno.remove(tempFile); + await fileHandle.close(); + + assertEquals(res.bytesWritten, 5); + assertEquals(decoder.decode(data), "hello"); +}); + +Deno.test("[node/fs filehandle.write] Write from string", async function () { + const tempFile: string = await Deno.makeTempFile(); + const fileHandle = await fs.open(tempFile, "a+"); + + const str = "hello world"; + const res = await fileHandle.write(str); + + const data = Deno.readFileSync(tempFile); + await Deno.remove(tempFile); + await fileHandle.close(); + + assertEquals(res.bytesWritten, 11); + assertEquals(decoder.decode(data), "hello world"); +}); diff --git a/tests/unit_node/_fs/_fs_link_test.ts b/tests/unit_node/_fs/_fs_link_test.ts new file mode 100644 index 000000000..15f15c706 --- /dev/null +++ b/tests/unit_node/_fs/_fs_link_test.ts @@ -0,0 +1,77 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import * as path from "@test_util/std/path/mod.ts"; +import { assert, assertEquals, fail } from "@test_util/std/assert/mod.ts"; +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; +import { link, linkSync } from "node:fs"; + +Deno.test({ + name: "ASYNC: hard linking files works as expected", + async fn() { + const tempFile: string = await Deno.makeTempFile(); + const linkedFile: string = tempFile + ".link"; + await new Promise<void>((res, rej) => { + link(tempFile, linkedFile, (err) => { + if (err) rej(err); + else res(); + }); + }) + .then(() => { + assertEquals(Deno.statSync(tempFile), Deno.statSync(linkedFile)); + }, () => { + fail("Expected to succeed"); + }) + .finally(() => { + Deno.removeSync(tempFile); + Deno.removeSync(linkedFile); + }); + }, +}); + +Deno.test({ + name: "ASYNC: hard linking files passes error to callback", + async fn() { + let failed = false; + await new Promise<void>((res, rej) => { + link("no-such-file", "no-such-file", (err) => { + if (err) rej(err); + else res(); + }); + }) + .then(() => { + fail("Expected to succeed"); + }, (err) => { + assert(err); + failed = true; + }); + assert(failed); + }, +}); + +Deno.test({ + name: "SYNC: hard linking files works as expected", + fn() { + const tempFile: string = Deno.makeTempFileSync(); + const linkedFile: string = tempFile + ".link"; + linkSync(tempFile, linkedFile); + + assertEquals(Deno.statSync(tempFile), Deno.statSync(linkedFile)); + Deno.removeSync(tempFile); + Deno.removeSync(linkedFile); + }, +}); + +Deno.test("[std/node/fs] link callback isn't called twice if error is thrown", async () => { + const tempDir = await Deno.makeTempDir(); + const tempFile = path.join(tempDir, "file.txt"); + const linkFile = path.join(tempDir, "link.txt"); + await Deno.writeTextFile(tempFile, "hello world"); + const importUrl = new URL("node:fs", import.meta.url); + await assertCallbackErrorUncaught({ + prelude: `import { link } from ${JSON.stringify(importUrl)}`, + invocation: `link(${JSON.stringify(tempFile)}, + ${JSON.stringify(linkFile)}, `, + async cleanup() { + await Deno.remove(tempDir, { recursive: true }); + }, + }); +}); diff --git a/tests/unit_node/_fs/_fs_lstat_test.ts b/tests/unit_node/_fs/_fs_lstat_test.ts new file mode 100644 index 000000000..ccd21a3cd --- /dev/null +++ b/tests/unit_node/_fs/_fs_lstat_test.ts @@ -0,0 +1,71 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { lstat, lstatSync } from "node:fs"; +import { fail } from "@test_util/std/assert/mod.ts"; +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; +import { assertStats, assertStatsBigInt } from "./_fs_stat_test.ts"; +import type { BigIntStats, Stats } from "node:fs"; + +Deno.test({ + name: "ASYNC: get a file Stats (lstat)", + async fn() { + const file = Deno.makeTempFileSync(); + await new Promise<Stats>((resolve, reject) => { + lstat(file, (err, stat) => { + if (err) reject(err); + resolve(stat); + }); + }) + .then((stat) => { + assertStats(stat, Deno.lstatSync(file)); + }, () => fail()) + .finally(() => { + Deno.removeSync(file); + }); + }, +}); + +Deno.test({ + name: "SYNC: get a file Stats (lstat)", + fn() { + const file = Deno.makeTempFileSync(); + assertStats(lstatSync(file), Deno.lstatSync(file)); + }, +}); + +Deno.test({ + name: "ASYNC: get a file BigInt Stats (lstat)", + async fn() { + const file = Deno.makeTempFileSync(); + await new Promise<BigIntStats>((resolve, reject) => { + lstat(file, { bigint: true }, (err, stat) => { + if (err) reject(err); + resolve(stat); + }); + }) + .then( + (stat) => assertStatsBigInt(stat, Deno.lstatSync(file)), + () => fail(), + ) + .finally(() => Deno.removeSync(file)); + }, +}); + +Deno.test({ + name: "SYNC: BigInt Stats (lstat)", + fn() { + const file = Deno.makeTempFileSync(); + assertStatsBigInt(lstatSync(file, { bigint: true }), Deno.lstatSync(file)); + }, +}); + +Deno.test("[std/node/fs] lstat callback isn't called twice if error is thrown", async () => { + const tempFile = await Deno.makeTempFile(); + const importUrl = new URL("node:fs", import.meta.url); + await assertCallbackErrorUncaught({ + prelude: `import { lstat } from ${JSON.stringify(importUrl)}`, + invocation: `lstat(${JSON.stringify(tempFile)}, `, + async cleanup() { + await Deno.remove(tempFile); + }, + }); +}); diff --git a/tests/unit_node/_fs/_fs_mkdir_test.ts b/tests/unit_node/_fs/_fs_mkdir_test.ts new file mode 100644 index 000000000..fb7fcf9c5 --- /dev/null +++ b/tests/unit_node/_fs/_fs_mkdir_test.ts @@ -0,0 +1,43 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import * as path from "@test_util/std/path/mod.ts"; +import { assert } from "@test_util/std/assert/mod.ts"; +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; +import { existsSync, mkdir, mkdirSync } from "node:fs"; + +const tmpDir = "./tmpdir"; + +Deno.test({ + name: "[node/fs] mkdir", + fn: async () => { + const result = await new Promise((resolve) => { + mkdir(tmpDir, (err) => { + err && resolve(false); + resolve(existsSync(tmpDir)); + Deno.removeSync(tmpDir); + }); + }); + assert(result); + }, +}); + +Deno.test({ + name: "[node/fs] mkdirSync", + fn: () => { + mkdirSync(tmpDir); + assert(existsSync(tmpDir)); + Deno.removeSync(tmpDir); + }, +}); + +Deno.test("[std/node/fs] mkdir callback isn't called twice if error is thrown", async () => { + const tempDir = await Deno.makeTempDir(); + const subdir = path.join(tempDir, "subdir"); + const importUrl = new URL("node:fs", import.meta.url); + await assertCallbackErrorUncaught({ + prelude: `import { mkdir } from ${JSON.stringify(importUrl)}`, + invocation: `mkdir(${JSON.stringify(subdir)}, `, + async cleanup() { + await Deno.remove(tempDir, { recursive: true }); + }, + }); +}); diff --git a/tests/unit_node/_fs/_fs_mkdtemp_test.ts b/tests/unit_node/_fs/_fs_mkdtemp_test.ts new file mode 100644 index 000000000..9f8975113 --- /dev/null +++ b/tests/unit_node/_fs/_fs_mkdtemp_test.ts @@ -0,0 +1,86 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { + assert, + assertRejects, + assertThrows, +} from "@test_util/std/assert/mod.ts"; +import { EncodingOption, existsSync, mkdtemp, mkdtempSync } from "node:fs"; +import { env } from "node:process"; +import { promisify } from "node:util"; + +const prefix = Deno.build.os === "windows" + ? env.TEMP + "\\" + : (env.TMPDIR || "/tmp") + "/"; +const doesNotExists = "/does/not/exists/"; +const options: EncodingOption = { encoding: "ascii" }; +const badOptions = { encoding: "bogus" }; + +const mkdtempP = promisify(mkdtemp); + +Deno.test({ + name: "[node/fs] mkdtemp", + fn: async () => { + const directory = await mkdtempP(prefix); + assert(existsSync(directory)); + Deno.removeSync(directory); + }, +}); + +Deno.test({ + name: "[node/fs] mkdtemp (does not exists)", + fn: async () => { + await assertRejects(() => mkdtempP(doesNotExists)); + }, +}); + +Deno.test({ + name: "[node/fs] mkdtemp (with options)", + fn: async () => { + const directory = await mkdtempP(prefix, options); + assert(existsSync(directory)); + Deno.removeSync(directory); + }, +}); + +Deno.test({ + name: "[node/fs] mkdtemp (with bad options)", + fn: async () => { + // @ts-expect-error No overload matches this call + await assertRejects(() => mkdtempP(prefix, badOptions)); + }, +}); + +Deno.test({ + name: "[node/fs] mkdtempSync", + fn: () => { + const directory = mkdtempSync(prefix); + const dirExists = existsSync(directory); + Deno.removeSync(directory); + assert(dirExists); + }, +}); + +Deno.test({ + name: "[node/fs] mkdtempSync (does not exists)", + fn: () => { + assertThrows(() => mkdtempSync(doesNotExists)); + }, +}); + +Deno.test({ + name: "[node/fs] mkdtempSync (with options)", + fn: () => { + const directory = mkdtempSync(prefix, options); + const dirExists = existsSync(directory); + Deno.removeSync(directory); + assert(dirExists); + }, +}); + +Deno.test({ + name: "[node/fs] mkdtempSync (with bad options)", + fn: () => { + // @ts-expect-error No overload matches this call + assertThrows(() => mkdtempSync(prefix, badOptions)); + }, +}); diff --git a/tests/unit_node/_fs/_fs_open_test.ts b/tests/unit_node/_fs/_fs_open_test.ts new file mode 100644 index 000000000..8cb9b0ec2 --- /dev/null +++ b/tests/unit_node/_fs/_fs_open_test.ts @@ -0,0 +1,400 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { + O_APPEND, + O_CREAT, + O_EXCL, + O_RDONLY, + O_RDWR, + O_SYNC, + O_TRUNC, + O_WRONLY, +} from "node:constants"; +import { assertEquals, assertThrows, fail } from "@test_util/std/assert/mod.ts"; +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; +import { open, openSync } from "node:fs"; +import { join, parse } from "node:path"; +import { closeSync, existsSync } from "node:fs"; + +const tempDir = parse(Deno.makeTempFileSync()).dir; + +Deno.test({ + name: "ASYNC: open file", + async fn() { + const file = Deno.makeTempFileSync(); + let fd1: number; + await new Promise<number>((resolve, reject) => { + open(file, (err, fd) => { + if (err) reject(err); + resolve(fd); + }); + }) + .then((fd) => { + fd1 = fd; + }, () => fail()) + .finally(() => closeSync(fd1)); + }, +}); + +Deno.test({ + name: "SYNC: open file", + fn() { + const file = Deno.makeTempFileSync(); + const fd = openSync(file, "r"); + closeSync(fd); + }, +}); + +Deno.test({ + name: "open with string flag 'a'", + fn() { + const file = join(tempDir, "some_random_file"); + const fd = openSync(file, "a"); + assertEquals(typeof fd, "number"); + assertEquals(existsSync(file), true); + closeSync(fd); + }, +}); + +Deno.test({ + name: "open with string flag 'ax'", + fn() { + const file = Deno.makeTempFileSync(); + assertThrows( + () => { + openSync(file, "ax"); + }, + Error, + `EEXIST: file already exists, open '${file}'`, + ); + Deno.removeSync(file); + }, +}); + +Deno.test({ + name: "open with string flag 'a+'", + fn() { + const file = join(tempDir, "some_random_file2"); + const fd = openSync(file, "a+"); + assertEquals(typeof fd, "number"); + assertEquals(existsSync(file), true); + closeSync(fd); + }, +}); + +Deno.test({ + name: "open with string flag 'ax+'", + fn() { + const file = Deno.makeTempFileSync(); + assertThrows( + () => { + openSync(file, "ax+"); + }, + Error, + `EEXIST: file already exists, open '${file}'`, + ); + Deno.removeSync(file); + }, +}); + +Deno.test({ + name: "open with string flag 'as'", + fn() { + const file = join(tempDir, "some_random_file10"); + const fd = openSync(file, "as"); + assertEquals(existsSync(file), true); + assertEquals(typeof fd, "number"); + closeSync(fd); + }, +}); + +Deno.test({ + name: "open with string flag 'as+'", + fn() { + const file = join(tempDir, "some_random_file10"); + const fd = openSync(file, "as+"); + assertEquals(existsSync(file), true); + assertEquals(typeof fd, "number"); + closeSync(fd); + }, +}); + +Deno.test({ + name: "open with string flag 'r'", + fn() { + const file = join(tempDir, "some_random_file3"); + assertThrows(() => { + openSync(file, "r"); + }, Error); + }, +}); + +Deno.test({ + name: "open with string flag 'r+'", + fn() { + const file = join(tempDir, "some_random_file4"); + assertThrows(() => { + openSync(file, "r+"); + }, Error); + }, +}); + +Deno.test({ + name: "open with string flag 'w'", + fn() { + const file = Deno.makeTempFileSync(); + Deno.writeTextFileSync(file, "hi there"); + const fd = openSync(file, "w"); + assertEquals(typeof fd, "number"); + assertEquals(Deno.readTextFileSync(file), ""); + closeSync(fd); + + const file2 = join(tempDir, "some_random_file5"); + const fd2 = openSync(file2, "w"); + assertEquals(typeof fd2, "number"); + assertEquals(existsSync(file2), true); + closeSync(fd2); + }, +}); + +Deno.test({ + name: "open with string flag 'wx'", + fn() { + const file = Deno.makeTempFileSync(); + Deno.writeTextFileSync(file, "hi there"); + const fd = openSync(file, "w"); + assertEquals(typeof fd, "number"); + assertEquals(Deno.readTextFileSync(file), ""); + closeSync(fd); + + const file2 = Deno.makeTempFileSync(); + assertThrows( + () => { + openSync(file2, "wx"); + }, + Error, + `EEXIST: file already exists, open '${file2}'`, + ); + }, +}); + +Deno.test({ + name: "open with string flag 'w+'", + fn() { + const file = Deno.makeTempFileSync(); + Deno.writeTextFileSync(file, "hi there"); + const fd = openSync(file, "w+"); + assertEquals(typeof fd, "number"); + assertEquals(Deno.readTextFileSync(file), ""); + closeSync(fd); + + const file2 = join(tempDir, "some_random_file6"); + const fd2 = openSync(file2, "w+"); + assertEquals(typeof fd2, "number"); + assertEquals(existsSync(file2), true); + closeSync(fd2); + }, +}); + +Deno.test({ + name: "open with string flag 'wx+'", + fn() { + const file = Deno.makeTempFileSync(); + assertThrows( + () => { + openSync(file, "wx+"); + }, + Error, + `EEXIST: file already exists, open '${file}'`, + ); + Deno.removeSync(file); + }, +}); + +Deno.test({ + name: "open with numeric flag `O_APPEND | O_CREAT | O_WRONLY` ('a')", + fn() { + const file = join(tempDir, "some_random_file"); + const fd = openSync(file, O_APPEND | O_CREAT | O_WRONLY); + assertEquals(typeof fd, "number"); + assertEquals(existsSync(file), true); + closeSync(fd); + }, +}); + +Deno.test({ + name: + "open with numeric flag `O_APPEND | O_CREAT | O_WRONLY | O_EXCL` ('ax')", + fn() { + const file = Deno.makeTempFileSync(); + assertThrows( + () => { + openSync(file, O_APPEND | O_CREAT | O_WRONLY | O_EXCL); + }, + Error, + `EEXIST: file already exists, open '${file}'`, + ); + Deno.removeSync(file); + }, +}); + +Deno.test({ + name: "open with numeric flag `O_APPEND | O_CREAT | O_RDWR` ('a+')", + fn() { + const file = join(tempDir, "some_random_file2"); + const fd = openSync(file, O_APPEND | O_CREAT | O_RDWR); + assertEquals(typeof fd, "number"); + assertEquals(existsSync(file), true); + closeSync(fd); + }, +}); + +Deno.test({ + name: "open with numeric flag `O_APPEND | O_CREAT | O_RDWR | O_EXCL` ('ax+')", + fn() { + const file = Deno.makeTempFileSync(); + assertThrows( + () => { + openSync(file, O_APPEND | O_CREAT | O_RDWR | O_EXCL); + }, + Error, + `EEXIST: file already exists, open '${file}'`, + ); + Deno.removeSync(file); + }, +}); + +Deno.test({ + name: + "open with numeric flag `O_APPEND | O_CREAT | O_WRONLY | O_SYNC` ('as')", + fn() { + const file = join(tempDir, "some_random_file10"); + const fd = openSync(file, O_APPEND | O_CREAT | O_WRONLY | O_SYNC); + assertEquals(existsSync(file), true); + assertEquals(typeof fd, "number"); + closeSync(fd); + }, +}); + +Deno.test({ + name: "open with numeric flag `O_APPEND | O_CREAT | O_RDWR | O_SYNC` ('as+')", + fn() { + const file = join(tempDir, "some_random_file10"); + const fd = openSync(file, O_APPEND | O_CREAT | O_RDWR | O_SYNC); + assertEquals(existsSync(file), true); + assertEquals(typeof fd, "number"); + closeSync(fd); + }, +}); + +Deno.test({ + name: "open with numeric flag `O_RDONLY` ('r')", + fn() { + const file = join(tempDir, "some_random_file3"); + assertThrows(() => { + openSync(file, O_RDONLY); + }, Error); + }, +}); + +Deno.test({ + name: "open with numeric flag `O_RDWR` ('r+')", + fn() { + const file = join(tempDir, "some_random_file4"); + assertThrows(() => { + openSync(file, O_RDWR); + }, Error); + }, +}); + +Deno.test({ + name: "open with numeric flag `O_TRUNC | O_CREAT | O_WRONLY` ('w')", + fn() { + const file = Deno.makeTempFileSync(); + Deno.writeTextFileSync(file, "hi there"); + const fd = openSync(file, O_TRUNC | O_CREAT | O_WRONLY); + assertEquals(typeof fd, "number"); + assertEquals(Deno.readTextFileSync(file), ""); + closeSync(fd); + + const file2 = join(tempDir, "some_random_file5"); + const fd2 = openSync(file2, O_TRUNC | O_CREAT | O_WRONLY); + assertEquals(typeof fd2, "number"); + assertEquals(existsSync(file2), true); + closeSync(fd2); + }, +}); + +Deno.test({ + name: "open with numeric flag `O_TRUNC | O_CREAT | O_WRONLY | O_EXCL` ('wx')", + fn() { + const file = Deno.makeTempFileSync(); + Deno.writeTextFileSync(file, "hi there"); + const fd = openSync(file, "w"); + assertEquals(typeof fd, "number"); + assertEquals(Deno.readTextFileSync(file), ""); + closeSync(fd); + + const file2 = Deno.makeTempFileSync(); + assertThrows( + () => { + openSync(file2, O_TRUNC | O_CREAT | O_WRONLY | O_EXCL); + }, + Error, + `EEXIST: file already exists, open '${file2}'`, + ); + }, +}); + +Deno.test({ + name: "open with numeric flag `O_TRUNC | O_CREAT | O_RDWR` ('w+')", + fn() { + const file = Deno.makeTempFileSync(); + Deno.writeTextFileSync(file, "hi there"); + const fd = openSync(file, O_TRUNC | O_CREAT | O_RDWR); + assertEquals(typeof fd, "number"); + assertEquals(Deno.readTextFileSync(file), ""); + closeSync(fd); + + const file2 = join(tempDir, "some_random_file6"); + const fd2 = openSync(file2, O_TRUNC | O_CREAT | O_RDWR); + assertEquals(typeof fd2, "number"); + assertEquals(existsSync(file2), true); + closeSync(fd2); + }, +}); + +Deno.test({ + name: "open with numeric flag `O_TRUNC | O_CREAT | O_RDWR | O_EXCL` ('wx+')", + fn() { + const file = Deno.makeTempFileSync(); + assertThrows( + () => { + openSync(file, O_TRUNC | O_CREAT | O_RDWR | O_EXCL); + }, + Error, + `EEXIST: file already exists, open '${file}'`, + ); + Deno.removeSync(file); + }, +}); + +Deno.test("[std/node/fs] open callback isn't called twice if error is thrown", async () => { + const tempFile = await Deno.makeTempFile(); + const importUrl = new URL("node:fs", import.meta.url); + await assertCallbackErrorUncaught({ + prelude: `import { open } from ${JSON.stringify(importUrl)}`, + invocation: `open(${JSON.stringify(tempFile)}, `, + async cleanup() { + await Deno.remove(tempFile); + }, + }); + + Deno.test({ + name: "SYNC: open file with flag set to 0 (readonly)", + fn() { + const file = Deno.makeTempFileSync(); + const fd = openSync(file, 0); + closeSync(fd); + }, + }); +}); diff --git a/tests/unit_node/_fs/_fs_opendir_test.ts b/tests/unit_node/_fs/_fs_opendir_test.ts new file mode 100644 index 000000000..d4abb349c --- /dev/null +++ b/tests/unit_node/_fs/_fs_opendir_test.ts @@ -0,0 +1,146 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import { + assert, + assertEquals, + assertFalse, + assertInstanceOf, + assertThrows, +} from "@test_util/std/assert/mod.ts"; +import { opendir, opendirSync } from "node:fs"; +import { Buffer } from "node:buffer"; +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; + +Deno.test("[node/fs] opendir()", async (t) => { + const path = await Deno.makeTempDir(); + const file = await Deno.makeTempFile(); + + await t.step( + "fails if encoding is invalid", + () => + opendir( + path, + // @ts-expect-error Type '"invalid-encoding"' is not assignable to type 'BufferEncoding | undefined' + { encoding: "invalid-encoding" }, + (err) => assertInstanceOf(err, TypeError), + ), + ); + + await t.step( + "fails if bufferSize is invalid", + () => + opendir( + path, + { bufferSize: -1 }, + (err) => assertInstanceOf(err, RangeError), + ), + ); + + await t.step( + "fails if directory does not exist", + () => + opendir( + "directory-that-does-not-exist", + (err) => assertInstanceOf(err, Error), + ), + ); + + await t.step( + "fails if not a directory", + () => + opendir( + file, + (err) => assertInstanceOf(err, Error), + ), + ); + + await t.step( + "passes if path is a string", + () => + opendir( + path, + (err, dir) => { + assertEquals(err, null); + assert(dir); + }, + ), + ); + + await t.step( + "passes if path is a Buffer", + () => + opendir( + Buffer.from(path), + (err, dir) => { + assertFalse(err); + assert(dir); + }, + ), + ); + + await t.step( + "passes if path is a URL", + () => + opendir( + new URL(`file://` + path), + (err, dir) => { + assertFalse(err); + assert(dir); + }, + ), + ); + + await t.step("passes if callback isn't called twice", async () => { + const importUrl = new URL("node:fs", import.meta.url); + await assertCallbackErrorUncaught({ + prelude: `import { opendir } from ${JSON.stringify(importUrl)}`, + invocation: `opendir(${JSON.stringify(path)}, `, + }); + }); + + await Deno.remove(path); + await Deno.remove(file); +}); + +Deno.test("[node/fs] opendirSync()", async (t) => { + const path = await Deno.makeTempDir(); + const file = await Deno.makeTempFile(); + + await t.step("fails if encoding is invalid", () => { + assertThrows( + // @ts-expect-error Type '"invalid-encoding"' is not assignable to type 'BufferEncoding | undefined' + () => opendirSync(path, { encoding: "invalid-encoding" }), + TypeError, + ); + }); + + await t.step("fails if bufferSize is invalid", () => { + assertThrows( + () => opendirSync(path, { bufferSize: -1 }), + RangeError, + ); + }); + + await t.step("fails if directory does not exist", () => { + assertThrows(() => opendirSync("directory-that-does-not-exist")); + }); + + await t.step("fails if not a directory", () => { + assertThrows(() => opendirSync(file)); + }); + + await t.step("passes if path is a string", () => { + assert(opendirSync(path)); + }); + + await t.step("passes if path is a Buffer", () => { + assert(opendirSync(Buffer.from(path))); + }); + + await t.step("passes if path is a URL", () => { + assert(opendirSync(new URL(`file://` + path))); + }); + + await Deno.remove(path); + await Deno.remove(file); +}); diff --git a/tests/unit_node/_fs/_fs_readFile_test.ts b/tests/unit_node/_fs/_fs_readFile_test.ts new file mode 100644 index 000000000..00653955d --- /dev/null +++ b/tests/unit_node/_fs/_fs_readFile_test.ts @@ -0,0 +1,123 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; +import { promises, readFile, readFileSync } from "node:fs"; +import * as path from "@test_util/std/path/mod.ts"; +import { assert, assertEquals } from "@test_util/std/assert/mod.ts"; + +const moduleDir = path.dirname(path.fromFileUrl(import.meta.url)); +const testData = path.resolve(moduleDir, "testdata", "hello.txt"); + +Deno.test("readFileSuccess", async function () { + const data = await new Promise((res, rej) => { + readFile(testData, (err, data) => { + if (err) { + rej(err); + } + res(data); + }); + }); + + assert(data instanceof Uint8Array); + assertEquals(new TextDecoder().decode(data as Uint8Array), "hello world"); +}); + +Deno.test("readFileEncodeUtf8Success", async function () { + const data = await new Promise((res, rej) => { + readFile(testData, { encoding: "utf8" }, (err, data) => { + if (err) { + rej(err); + } + res(data); + }); + }); + assertEquals(typeof data, "string"); + assertEquals(data as string, "hello world"); +}); + +Deno.test("readFileEncodeHexSuccess", async function () { + const data = await new Promise((res, rej) => { + readFile(testData, { encoding: "hex" }, (err, data) => { + if (err) { + rej(err); + } + res(data); + }); + }); + + assertEquals(typeof data, "string"); + assertEquals(data as string, "68656c6c6f20776f726c64"); +}); + +Deno.test("readFileEncodeBase64Success", async function () { + const data = await new Promise((res, rej) => { + readFile(testData, { encoding: "base64" }, (err, data) => { + if (err) { + rej(err); + } + res(data); + }); + }); + assertEquals(typeof data, "string"); + assertEquals(data as string, "aGVsbG8gd29ybGQ="); +}); + +Deno.test("readFileEncodingAsString", async function () { + const data = await new Promise((res, rej) => { + readFile(testData, "utf8", (err, data) => { + if (err) { + rej(err); + } + res(data); + }); + }); + + assertEquals(typeof data, "string"); + assertEquals(data as string, "hello world"); +}); + +Deno.test("readFileSyncSuccess", function () { + const data = readFileSync(testData); + assert(data instanceof Uint8Array); + assertEquals(new TextDecoder().decode(data as Uint8Array), "hello world"); +}); + +Deno.test("readFileEncodeUtf8Success", function () { + const data = readFileSync(testData, { encoding: "utf8" }); + assertEquals(typeof data, "string"); + assertEquals(data as string, "hello world"); +}); + +Deno.test("readFileEncodeHexSuccess", function () { + const data = readFileSync(testData, { encoding: "hex" }); + assertEquals(typeof data, "string"); + assertEquals(data as string, "68656c6c6f20776f726c64"); +}); + +Deno.test("readFileEncodeBase64Success", function () { + const data = readFileSync(testData, { encoding: "base64" }); + assertEquals(typeof data, "string"); + assertEquals(data as string, "aGVsbG8gd29ybGQ="); +}); + +Deno.test("readFileEncodeAsString", function () { + const data = readFileSync(testData, "utf8"); + assertEquals(typeof data, "string"); + assertEquals(data as string, "hello world"); +}); + +Deno.test("[std/node/fs] readFile callback isn't called twice if error is thrown", async () => { + const tempFile = await Deno.makeTempFile(); + const importUrl = new URL("node:fs", import.meta.url); + await assertCallbackErrorUncaught({ + prelude: `import { readFile } from ${JSON.stringify(importUrl)}`, + invocation: `readFile(${JSON.stringify(tempFile)}, `, + async cleanup() { + await Deno.remove(tempFile); + }, + }); +}); + +Deno.test("fs.promises.readFile with no arg call rejects with error correctly", async () => { + // @ts-ignore no arg call needs to be supported + await promises.readFile().catch((_e) => {}); +}); diff --git a/tests/unit_node/_fs/_fs_read_test.ts b/tests/unit_node/_fs/_fs_read_test.ts new file mode 100644 index 000000000..de741e377 --- /dev/null +++ b/tests/unit_node/_fs/_fs_read_test.ts @@ -0,0 +1,322 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { + assertEquals, + assertFalse, + assertMatch, + assertStrictEquals, +} from "@test_util/std/assert/mod.ts"; +import { read, readSync } from "node:fs"; +import { open, openSync } from "node:fs"; +import { Buffer } from "node:buffer"; +import * as path from "@test_util/std/path/mod.ts"; +import { closeSync } from "node:fs"; + +async function readTest( + testData: string, + buffer: Buffer, + offset: number, + length: number, + position: number | null = null, + expected: ( + fd: number, + bytesRead: number | null, + data: Buffer | undefined, + ) => void, +) { + let fd1 = 0; + await new Promise<{ + fd: number; + bytesRead: number | null; + data: Buffer | undefined; + }>((resolve, reject) => { + open(testData, "r", (err, fd) => { + if (err) reject(err); + read(fd, buffer, offset, length, position, (err, bytesRead, data) => { + if (err) reject(err); + resolve({ fd, bytesRead, data }); + }); + }); + }) + .then(({ fd, bytesRead, data }) => { + fd1 = fd; + expected(fd, bytesRead, data); + }) + .finally(() => closeSync(fd1)); +} + +Deno.test({ + name: "readSuccess", + async fn() { + const moduleDir = path.dirname(path.fromFileUrl(import.meta.url)); + const testData = path.resolve(moduleDir, "testdata", "hello.txt"); + const buf = Buffer.alloc(1024); + await readTest( + testData, + buf, + buf.byteOffset, + buf.byteLength, + null, + (_fd, bytesRead, data) => { + assertStrictEquals(bytesRead, 11); + assertEquals(data instanceof Buffer, true); + assertMatch((data as Buffer).toString(), /hello world/); + }, + ); + }, +}); + +Deno.test({ + name: + "[std/node/fs] Read only five bytes, so that the position moves to five", + async fn() { + const moduleDir = path.dirname(path.fromFileUrl(import.meta.url)); + const testData = path.resolve(moduleDir, "testdata", "hello.txt"); + const buf = Buffer.alloc(5); + await readTest( + testData, + buf, + buf.byteOffset, + 5, + null, + (_fd, bytesRead, data) => { + assertStrictEquals(bytesRead, 5); + assertEquals(data instanceof Buffer, true); + assertEquals((data as Buffer).toString(), "hello"); + }, + ); + }, +}); + +Deno.test({ + name: + "[std/node/fs] position option of fs.read() specifies where to begin reading from in the file", + async fn() { + const moduleDir = path.dirname(path.fromFileUrl(import.meta.url)); + const testData = path.resolve(moduleDir, "testdata", "hello.txt"); + const fd = openSync(testData, "r"); + const buf = Buffer.alloc(5); + const positions = [6, 0, -1, null]; + const expected = [ + [119, 111, 114, 108, 100], + [104, 101, 108, 108, 111], + [104, 101, 108, 108, 111], + [32, 119, 111, 114, 108], + ]; + for (const [i, position] of positions.entries()) { + await new Promise((resolve) => { + read( + fd, + { + buffer: buf, + offset: buf.byteOffset, + length: buf.byteLength, + position, + }, + (err, bytesRead, data) => { + assertEquals(err, null); + assertStrictEquals(bytesRead, 5); + assertEquals( + data, + Buffer.from(expected[i]), + ); + return resolve(true); + }, + ); + }); + } + closeSync(fd); + }, +}); + +Deno.test({ + name: "[std/node/fs] Read fs.read(fd, options, cb) signature", + async fn() { + const { promise, reject, resolve } = Promise.withResolvers<void>(); + const file = Deno.makeTempFileSync(); + Deno.writeTextFileSync(file, "hi there"); + const fd = openSync(file, "r+"); + const buf = Buffer.alloc(11); + read( + fd, + { + buffer: buf, + offset: buf.byteOffset, + length: buf.byteLength, + position: null, + }, + (err, bytesRead, data) => { + try { + assertEquals(err, null); + assertStrictEquals(bytesRead, 8); + assertEquals( + data, + Buffer.from([104, 105, 32, 116, 104, 101, 114, 101, 0, 0, 0]), + ); + } catch (e) { + reject(e); + return; + } + resolve(); + }, + ); + closeSync(fd); + await promise; + }, +}); + +Deno.test({ + name: "[std/node/fs] Read fs.read(fd, cb) signature", + async fn() { + const { promise, resolve, reject } = Promise.withResolvers<void>(); + const file = Deno.makeTempFileSync(); + Deno.writeTextFileSync(file, "hi deno"); + const fd = openSync(file, "r+"); + read(fd, (err, bytesRead, data) => { + try { + assertEquals(err, null); + assertStrictEquals(bytesRead, 7); + assertStrictEquals(data?.byteLength, 16384); + } catch (e) { + reject(e); + return; + } + resolve(); + }); + closeSync(fd); + await promise; + }, +}); + +Deno.test({ + name: "SYNC: readSuccess", + fn() { + const moduleDir = path.dirname(path.fromFileUrl(import.meta.url)); + const testData = path.resolve(moduleDir, "testdata", "hello.txt"); + const buffer = Buffer.alloc(1024); + const fd = openSync(testData, "r"); + const bytesRead = readSync( + fd, + buffer, + buffer.byteOffset, + buffer.byteLength, + null, + ); + assertStrictEquals(bytesRead, 11); + closeSync(fd); + }, +}); + +Deno.test({ + name: "[std/node/fs] Read only two bytes, so that the position moves to two", + fn() { + const moduleDir = path.dirname(path.fromFileUrl(import.meta.url)); + const testData = path.resolve(moduleDir, "testdata", "hello.txt"); + const buffer = Buffer.alloc(2); + const fd = openSync(testData, "r"); + const bytesRead = readSync(fd, buffer, buffer.byteOffset, 2, null); + assertStrictEquals(bytesRead, 2); + closeSync(fd); + }, +}); + +Deno.test({ + name: + "[std/node/fs] position option of fs.readSync() specifies where to begin reading from in the file", + fn() { + const moduleDir = path.dirname(path.fromFileUrl(import.meta.url)); + const testData = path.resolve(moduleDir, "testdata", "hello.txt"); + const fd = openSync(testData, "r"); + const buf = Buffer.alloc(5); + const positions = [6, 0, -1, null]; + const expected = [ + [119, 111, 114, 108, 100], + [104, 101, 108, 108, 111], + [104, 101, 108, 108, 111], + [32, 119, 111, 114, 108], + ]; + for (const [i, position] of positions.entries()) { + const bytesRead = readSync( + fd, + buf, + buf.byteOffset, + buf.byteLength, + position, + ); + assertStrictEquals(bytesRead, 5); + assertEquals( + buf, + Buffer.from(expected[i]), + ); + } + closeSync(fd); + }, +}); + +Deno.test({ + name: "[std/node/fs] Read fs.readSync(fd, buffer[, options]) signature", + fn() { + const file = Deno.makeTempFileSync(); + Deno.writeTextFileSync(file, "hello deno"); + const buffer = Buffer.alloc(1024); + const fd = openSync(file, "r+"); + const bytesRead = readSync(fd, buffer, { + length: buffer.byteLength, + offset: buffer.byteOffset, + position: null, + }); + assertStrictEquals(bytesRead, 10); + closeSync(fd); + }, +}); + +Deno.test({ + name: "[std/node/fs] fs.read is async", + async fn(t) { + const file = await Deno.makeTempFile(); + await Deno.writeTextFile(file, "abc"); + + await t.step("without position option", async () => { + const { promise, resolve } = Promise.withResolvers<void>(); + let called = false; + const fd = openSync(file, "r"); + read(fd, () => { + called = true; + closeSync(fd); + resolve(); + }); + assertFalse(called); + await promise; + }); + + await t.step("with position option", async () => { + const { promise, resolve } = Promise.withResolvers<void>(); + let called = false; + const buffer = Buffer.alloc(2); + const fd = openSync(file, "r"); + read(fd, { position: 1, buffer, offset: 0, length: 2 }, () => { + called = true; + closeSync(fd); + resolve(); + }); + assertFalse(called); + await promise; + }); + + await Deno.remove(file); + }, +}); + +Deno.test({ + name: "SYNC: read with no offsetOropts argument", + fn() { + const moduleDir = path.dirname(path.fromFileUrl(import.meta.url)); + const testData = path.resolve(moduleDir, "testdata", "hello.txt"); + const buffer = Buffer.alloc(1024); + const fd = openSync(testData, "r"); + const _bytesRead = readSync( + fd, + buffer, + ); + closeSync(fd); + }, +}); diff --git a/tests/unit_node/_fs/_fs_readdir_test.ts b/tests/unit_node/_fs/_fs_readdir_test.ts new file mode 100644 index 000000000..eaacbfc5e --- /dev/null +++ b/tests/unit_node/_fs/_fs_readdir_test.ts @@ -0,0 +1,96 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { + assertEquals, + assertNotEquals, + fail, +} from "@test_util/std/assert/mod.ts"; +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; +import { readdir, readdirSync } from "node:fs"; +import { join } from "@test_util/std/path/mod.ts"; + +Deno.test({ + name: "ASYNC: reading empty directory", + async fn() { + const dir = Deno.makeTempDirSync(); + await new Promise<string[]>((resolve, reject) => { + readdir(dir, (err, files) => { + if (err) reject(err); + resolve(files); + }); + }) + .then((files) => assertEquals(files, []), () => fail()) + .finally(() => Deno.removeSync(dir)); + }, +}); + +function assertEqualsArrayAnyOrder<T>(actual: T[], expected: T[]) { + assertEquals(actual.length, expected.length); + for (const item of expected) { + const index = actual.indexOf(item); + assertNotEquals(index, -1); + expected = expected.splice(index, 1); + } +} + +Deno.test({ + name: "ASYNC: reading non-empty directory", + async fn() { + const dir = Deno.makeTempDirSync(); + Deno.writeTextFileSync(join(dir, "file1.txt"), "hi"); + Deno.writeTextFileSync(join(dir, "file2.txt"), "hi"); + Deno.mkdirSync(join(dir, "some_dir")); + await new Promise<string[]>((resolve, reject) => { + readdir(dir, (err, files) => { + if (err) reject(err); + resolve(files); + }); + }) + .then( + (files) => + assertEqualsArrayAnyOrder( + files, + ["file1.txt", "some_dir", "file2.txt"], + ), + () => fail(), + ) + .finally(() => Deno.removeSync(dir, { recursive: true })); + }, +}); + +Deno.test({ + name: "SYNC: reading empty the directory", + fn() { + const dir = Deno.makeTempDirSync(); + assertEquals(readdirSync(dir), []); + }, +}); + +Deno.test({ + name: "SYNC: reading non-empty directory", + fn() { + const dir = Deno.makeTempDirSync(); + Deno.writeTextFileSync(join(dir, "file1.txt"), "hi"); + Deno.writeTextFileSync(join(dir, "file2.txt"), "hi"); + Deno.mkdirSync(join(dir, "some_dir")); + assertEqualsArrayAnyOrder( + readdirSync(dir), + ["file1.txt", "some_dir", "file2.txt"], + ); + }, +}); + +Deno.test("[std/node/fs] readdir callback isn't called twice if error is thrown", async () => { + // The correct behaviour is not to catch any errors thrown, + // but that means there'll be an uncaught error and the test will fail. + // So the only way to test this is to spawn a subprocess, and succeed if it has a non-zero exit code. + // (assertRejects won't work because there's no way to catch the error.) + const tempDir = await Deno.makeTempDir(); + const importUrl = new URL("node:fs", import.meta.url); + await assertCallbackErrorUncaught({ + prelude: `import { readdir } from ${JSON.stringify(importUrl)}`, + invocation: `readdir(${JSON.stringify(tempDir)}, `, + async cleanup() { + await Deno.remove(tempDir); + }, + }); +}); diff --git a/tests/unit_node/_fs/_fs_readlink_test.ts b/tests/unit_node/_fs/_fs_readlink_test.ts new file mode 100644 index 000000000..02d84c6c3 --- /dev/null +++ b/tests/unit_node/_fs/_fs_readlink_test.ts @@ -0,0 +1,75 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; +import { readlink, readlinkSync } from "node:fs"; +import { assert, assertEquals } from "@test_util/std/assert/mod.ts"; +import * as path from "@test_util/std/path/mod.ts"; + +const testDir = Deno.makeTempDirSync(); +const oldname = path.join(testDir, "oldname"); +const newname = path.join(testDir, "newname"); + +if (Deno.build.os === "windows") { + Deno.symlinkSync(oldname, newname, { type: "file" }); +} else { + Deno.symlinkSync(oldname, newname); +} + +Deno.test({ + name: "readlinkSuccess", + async fn() { + const data = await new Promise((res, rej) => { + readlink(newname, (err, data) => { + if (err) { + rej(err); + } + res(data); + }); + }); + + assertEquals(typeof data, "string"); + assertEquals(data as string, oldname); + }, +}); + +Deno.test({ + name: "readlinkEncodeBufferSuccess", + async fn() { + const data = await new Promise((res, rej) => { + readlink(newname, { encoding: "buffer" }, (err, data) => { + if (err) { + rej(err); + } + res(data); + }); + }); + + assert(data instanceof Uint8Array); + assertEquals(new TextDecoder().decode(data as Uint8Array), oldname); + }, +}); + +Deno.test({ + name: "readlinkSyncSuccess", + fn() { + const data = readlinkSync(newname); + assertEquals(typeof data, "string"); + assertEquals(data as string, oldname); + }, +}); + +Deno.test({ + name: "readlinkEncodeBufferSuccess", + fn() { + const data = readlinkSync(newname, { encoding: "buffer" }); + assert(data instanceof Uint8Array); + assertEquals(new TextDecoder().decode(data as Uint8Array), oldname); + }, +}); + +Deno.test("[std/node/fs] readlink callback isn't called twice if error is thrown", async () => { + const importUrl = new URL("node:fs", import.meta.url); + await assertCallbackErrorUncaught({ + prelude: `import { readlink } from ${JSON.stringify(importUrl)}`, + invocation: `readlink(${JSON.stringify(newname)}, `, + }); +}); diff --git a/tests/unit_node/_fs/_fs_realpath_test.ts b/tests/unit_node/_fs/_fs_realpath_test.ts new file mode 100644 index 000000000..6f22ff72a --- /dev/null +++ b/tests/unit_node/_fs/_fs_realpath_test.ts @@ -0,0 +1,55 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import * as path from "@test_util/std/path/mod.ts"; +import { assertEquals } from "@test_util/std/assert/mod.ts"; +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; +import { realpath, realpathSync } from "node:fs"; + +Deno.test("realpath", async function () { + const tempFile = await Deno.makeTempFile(); + const tempFileAlias = tempFile + ".alias"; + await Deno.symlink(tempFile, tempFileAlias); + const realPath = await new Promise((resolve, reject) => { + realpath(tempFile, (err, path) => { + if (err) { + reject(err); + return; + } + resolve(path); + }); + }); + const realSymLinkPath = await new Promise((resolve, reject) => { + realpath(tempFileAlias, (err, path) => { + if (err) { + reject(err); + return; + } + resolve(path); + }); + }); + assertEquals(realPath, realSymLinkPath); +}); + +Deno.test("realpathSync", function () { + const tempFile = Deno.makeTempFileSync(); + const tempFileAlias = tempFile + ".alias"; + Deno.symlinkSync(tempFile, tempFileAlias); + const realPath = realpathSync(tempFile); + const realSymLinkPath = realpathSync(tempFileAlias); + assertEquals(realPath, realSymLinkPath); +}); + +Deno.test("[std/node/fs] realpath callback isn't called twice if error is thrown", async () => { + const tempDir = await Deno.makeTempDir(); + const tempFile = path.join(tempDir, "file.txt"); + const linkFile = path.join(tempDir, "link.txt"); + await Deno.writeTextFile(tempFile, "hello world"); + await Deno.symlink(tempFile, linkFile, { type: "file" }); + const importUrl = new URL("node:fs", import.meta.url); + await assertCallbackErrorUncaught({ + prelude: `import { realpath } from ${JSON.stringify(importUrl)}`, + invocation: `realpath(${JSON.stringify(`${tempDir}/link.txt`)}, `, + async cleanup() { + await Deno.remove(tempDir, { recursive: true }); + }, + }); +}); diff --git a/tests/unit_node/_fs/_fs_rename_test.ts b/tests/unit_node/_fs/_fs_rename_test.ts new file mode 100644 index 000000000..dd0a01f8a --- /dev/null +++ b/tests/unit_node/_fs/_fs_rename_test.ts @@ -0,0 +1,52 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { assertEquals, fail } from "@test_util/std/assert/mod.ts"; +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; +import { rename, renameSync } from "node:fs"; +import { existsSync } from "node:fs"; +import { join, parse } from "@test_util/std/path/mod.ts"; + +Deno.test({ + name: "ASYNC: renaming a file", + async fn() { + const file = Deno.makeTempFileSync(); + const newPath = join(parse(file).dir, `${parse(file).base}_renamed`); + await new Promise<void>((resolve, reject) => { + rename(file, newPath, (err) => { + if (err) reject(err); + resolve(); + }); + }) + .then(() => { + assertEquals(existsSync(newPath), true); + assertEquals(existsSync(file), false); + }, () => fail()) + .finally(() => { + if (existsSync(file)) Deno.removeSync(file); + if (existsSync(newPath)) Deno.removeSync(newPath); + }); + }, +}); + +Deno.test({ + name: "SYNC: renaming a file", + fn() { + const file = Deno.makeTempFileSync(); + const newPath = join(parse(file).dir, `${parse(file).base}_renamed`); + renameSync(file, newPath); + assertEquals(existsSync(newPath), true); + assertEquals(existsSync(file), false); + }, +}); + +Deno.test("[std/node/fs] rename callback isn't called twice if error is thrown", async () => { + const tempFile = await Deno.makeTempFile(); + const importUrl = new URL("node:fs", import.meta.url); + await assertCallbackErrorUncaught({ + prelude: `import { rename } from ${JSON.stringify(importUrl)}`, + invocation: `rename(${JSON.stringify(tempFile)}, + ${JSON.stringify(`${tempFile}.newname`)}, `, + async cleanup() { + await Deno.remove(`${tempFile}.newname`); + }, + }); +}); diff --git a/tests/unit_node/_fs/_fs_rm_test.ts b/tests/unit_node/_fs/_fs_rm_test.ts new file mode 100644 index 000000000..1cc82a0cc --- /dev/null +++ b/tests/unit_node/_fs/_fs_rm_test.ts @@ -0,0 +1,139 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { + assertEquals, + assertRejects, + assertThrows, + fail, +} from "@test_util/std/assert/mod.ts"; +import { rm, rmSync } from "node:fs"; +import { existsSync } from "node:fs"; +import { join } from "@test_util/std/path/mod.ts"; + +Deno.test({ + name: "ASYNC: removing empty folder", + async fn() { + const dir = Deno.makeTempDirSync(); + await new Promise<void>((resolve, reject) => { + rm(dir, { recursive: true }, (err) => { + if (err) reject(err); + resolve(); + }); + }) + .then(() => assertEquals(existsSync(dir), false), () => fail()) + .finally(() => { + if (existsSync(dir)) Deno.removeSync(dir); + }); + }, +}); + +Deno.test({ + name: "ASYNC: removing non-empty folder", + async fn() { + const dir = Deno.makeTempDirSync(); + using _file1 = Deno.createSync(join(dir, "file1.txt")); + using _file2 = Deno.createSync(join(dir, "file2.txt")); + Deno.mkdirSync(join(dir, "some_dir")); + using _file = Deno.createSync(join(dir, "some_dir", "file.txt")); + await new Promise<void>((resolve, reject) => { + rm(dir, { recursive: true }, (err) => { + if (err) reject(err); + resolve(); + }); + }) + .then(() => assertEquals(existsSync(dir), false), () => fail()) + .finally(() => { + if (existsSync(dir)) Deno.removeSync(dir, { recursive: true }); + }); + }, + ignore: Deno.build.os === "windows", +}); + +Deno.test({ + name: "ASYNC: removing a file", + async fn() { + const file = Deno.makeTempFileSync(); + await new Promise<void>((resolve, reject) => { + rm(file, (err) => { + if (err) reject(err); + resolve(); + }); + }); + + assertEquals(existsSync(file), false); + }, +}); + +Deno.test({ + name: "ASYNC: remove should fail if target does not exist", + async fn() { + const removePromise = new Promise<void>((resolve, reject) => { + rm("/path/to/noexist.text", (err) => { + if (err) reject(err); + resolve(); + }); + }); + await assertRejects(() => removePromise, Error); + }, +}); + +Deno.test({ + name: + "ASYNC: remove should not fail if target does not exist and force option is true", + async fn() { + await new Promise<void>((resolve, reject) => { + rm("/path/to/noexist.text", { force: true }, (err) => { + if (err) reject(err); + resolve(); + }); + }); + }, +}); + +Deno.test({ + name: "SYNC: removing empty folder", + fn() { + const dir = Deno.makeTempDirSync(); + rmSync(dir, { recursive: true }); + assertEquals(existsSync(dir), false); + }, +}); + +Deno.test({ + name: "SYNC: removing non-empty folder", + fn() { + const dir = Deno.makeTempDirSync(); + using _file1 = Deno.createSync(join(dir, "file1.txt")); + using _file2 = Deno.createSync(join(dir, "file2.txt")); + Deno.mkdirSync(join(dir, "some_dir")); + using _file = Deno.createSync(join(dir, "some_dir", "file.txt")); + rmSync(dir, { recursive: true }); + assertEquals(existsSync(dir), false); + }, + ignore: Deno.build.os === "windows", +}); + +Deno.test({ + name: "SYNC: removing a file", + fn() { + const file = Deno.makeTempFileSync(); + + rmSync(file); + + assertEquals(existsSync(file), false); + }, +}); + +Deno.test({ + name: "SYNC: remove should fail if target does not exist", + fn() { + assertThrows(() => rmSync("/path/to/noexist.text"), Error); + }, +}); + +Deno.test({ + name: + "SYNC: remove should not fail if target does not exist and force option is true", + fn() { + rmSync("/path/to/noexist.text", { force: true }); + }, +}); diff --git a/tests/unit_node/_fs/_fs_rmdir_test.ts b/tests/unit_node/_fs/_fs_rmdir_test.ts new file mode 100644 index 000000000..d2b075bdf --- /dev/null +++ b/tests/unit_node/_fs/_fs_rmdir_test.ts @@ -0,0 +1,81 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { assertEquals, fail } from "@test_util/std/assert/mod.ts"; +import { rmdir, rmdirSync } from "node:fs"; +import { existsSync } from "node:fs"; +import { join } from "@test_util/std/path/mod.ts"; +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; + +Deno.test({ + name: "ASYNC: removing empty folder", + async fn() { + const dir = Deno.makeTempDirSync(); + await new Promise<void>((resolve, reject) => { + rmdir(dir, (err) => { + if (err) reject(err); + resolve(); + }); + }) + .then(() => assertEquals(existsSync(dir), false), () => fail()) + .finally(() => { + if (existsSync(dir)) Deno.removeSync(dir); + }); + }, +}); + +Deno.test({ + name: "SYNC: removing empty folder", + fn() { + const dir = Deno.makeTempDirSync(); + rmdirSync(dir); + assertEquals(existsSync(dir), false); + }, +}); + +Deno.test({ + name: "ASYNC: removing non-empty folder", + async fn() { + const dir = Deno.makeTempDirSync(); + using _file1 = Deno.createSync(join(dir, "file1.txt")); + using _file2 = Deno.createSync(join(dir, "file2.txt")); + Deno.mkdirSync(join(dir, "some_dir")); + using _file = Deno.createSync(join(dir, "some_dir", "file.txt")); + await new Promise<void>((resolve, reject) => { + rmdir(dir, { recursive: true }, (err) => { + if (err) reject(err); + resolve(); + }); + }) + .then(() => assertEquals(existsSync(dir), false), () => fail()) + .finally(() => { + if (existsSync(dir)) Deno.removeSync(dir, { recursive: true }); + }); + }, + ignore: Deno.build.os === "windows", +}); + +Deno.test({ + name: "SYNC: removing non-empty folder", + fn() { + const dir = Deno.makeTempDirSync(); + using _file1 = Deno.createSync(join(dir, "file1.txt")); + using _file2 = Deno.createSync(join(dir, "file2.txt")); + Deno.mkdirSync(join(dir, "some_dir")); + using _file = Deno.createSync(join(dir, "some_dir", "file.txt")); + rmdirSync(dir, { recursive: true }); + assertEquals(existsSync(dir), false); + }, + ignore: Deno.build.os === "windows", +}); + +Deno.test("[std/node/fs] rmdir callback isn't called twice if error is thrown", async () => { + // The correct behaviour is not to catch any errors thrown, + // but that means there'll be an uncaught error and the test will fail. + // So the only way to test this is to spawn a subprocess, and succeed if it has a non-zero exit code. + // (assertRejects won't work because there's no way to catch the error.) + const tempDir = await Deno.makeTempDir(); + const importUrl = new URL("node:fs", import.meta.url); + await assertCallbackErrorUncaught({ + prelude: `import { rmdir } from ${JSON.stringify(importUrl)}`, + invocation: `rmdir(${JSON.stringify(tempDir)}, `, + }); +}); diff --git a/tests/unit_node/_fs/_fs_stat_test.ts b/tests/unit_node/_fs/_fs_stat_test.ts new file mode 100644 index 000000000..38d5ca985 --- /dev/null +++ b/tests/unit_node/_fs/_fs_stat_test.ts @@ -0,0 +1,131 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; +import { BigIntStats, stat, Stats, statSync } from "node:fs"; +import { assertEquals, fail } from "@test_util/std/assert/mod.ts"; + +export function assertStats(actual: Stats, expected: Deno.FileInfo) { + assertEquals(actual.dev, expected.dev); + assertEquals(actual.gid, expected.gid); + assertEquals(actual.size, expected.size); + assertEquals(actual.blksize, expected.blksize); + assertEquals(actual.blocks, expected.blocks); + assertEquals(actual.ino, expected.ino); + assertEquals(actual.gid, expected.gid); + assertEquals(actual.mode, expected.mode); + assertEquals(actual.nlink, expected.nlink); + assertEquals(actual.rdev, expected.rdev); + assertEquals(actual.uid, expected.uid); + assertEquals(actual.atime?.getTime(), expected.atime?.getTime()); + assertEquals(actual.mtime?.getTime(), expected.mtime?.getTime()); + assertEquals(actual.birthtime?.getTime(), expected.birthtime?.getTime()); + assertEquals(actual.atimeMs ?? undefined, expected.atime?.getTime()); + assertEquals(actual.mtimeMs ?? undefined, expected.mtime?.getTime()); + assertEquals(actual.birthtimeMs ?? undefined, expected.birthtime?.getTime()); + assertEquals(actual.isFile(), expected.isFile); + assertEquals(actual.isDirectory(), expected.isDirectory); + assertEquals(actual.isSymbolicLink(), expected.isSymlink); +} + +function toBigInt(num?: number | null) { + if (num === undefined || num === null) return null; + return BigInt(num); +} + +export function assertStatsBigInt( + actual: BigIntStats, + expected: Deno.FileInfo, +) { + assertEquals(actual.dev, toBigInt(expected.dev)); + assertEquals(actual.gid, toBigInt(expected.gid)); + assertEquals(actual.size, toBigInt(expected.size)); + assertEquals(actual.blksize, toBigInt(expected.blksize)); + assertEquals(actual.blocks, toBigInt(expected.blocks)); + assertEquals(actual.ino, toBigInt(expected.ino)); + assertEquals(actual.gid, toBigInt(expected.gid)); + assertEquals(actual.mode, toBigInt(expected.mode)); + assertEquals(actual.nlink, toBigInt(expected.nlink)); + assertEquals(actual.rdev, toBigInt(expected.rdev)); + assertEquals(actual.uid, toBigInt(expected.uid)); + assertEquals(actual.atime?.getTime(), expected.atime?.getTime()); + assertEquals(actual.mtime?.getTime(), expected.mtime?.getTime()); + assertEquals(actual.birthtime?.getTime(), expected.birthtime?.getTime()); + assertEquals( + actual.atimeMs === null ? undefined : Number(actual.atimeMs), + expected.atime?.getTime(), + ); + assertEquals( + actual.mtimeMs === null ? undefined : Number(actual.mtimeMs), + expected.mtime?.getTime(), + ); + assertEquals( + actual.birthtimeMs === null ? undefined : Number(actual.birthtimeMs), + expected.birthtime?.getTime(), + ); + assertEquals(actual.atimeNs === null, actual.atime === null); + assertEquals(actual.mtimeNs === null, actual.mtime === null); + assertEquals(actual.birthtimeNs === null, actual.birthtime === null); + assertEquals(actual.isFile(), expected.isFile); + assertEquals(actual.isDirectory(), expected.isDirectory); + assertEquals(actual.isSymbolicLink(), expected.isSymlink); +} + +Deno.test({ + name: "ASYNC: get a file Stats", + async fn() { + const file = Deno.makeTempFileSync(); + await new Promise<Stats>((resolve, reject) => { + stat(file, (err, stat) => { + if (err) reject(err); + resolve(stat); + }); + }) + .then((stat) => assertStats(stat, Deno.statSync(file)), () => fail()) + .finally(() => Deno.removeSync(file)); + }, +}); + +Deno.test({ + name: "SYNC: get a file Stats", + fn() { + const file = Deno.makeTempFileSync(); + assertStats(statSync(file), Deno.statSync(file)); + }, +}); + +Deno.test({ + name: "ASYNC: get a file BigInt Stats", + async fn() { + const file = Deno.makeTempFileSync(); + await new Promise<BigIntStats>((resolve, reject) => { + stat(file, { bigint: true }, (err, stat) => { + if (err) reject(err); + resolve(stat); + }); + }) + .then( + (stat) => assertStatsBigInt(stat, Deno.statSync(file)), + () => fail(), + ) + .finally(() => Deno.removeSync(file)); + }, +}); + +Deno.test({ + name: "SYNC: get a file BigInt Stats", + fn() { + const file = Deno.makeTempFileSync(); + assertStatsBigInt(statSync(file, { bigint: true }), Deno.statSync(file)); + }, +}); + +Deno.test("[std/node/fs] stat callback isn't called twice if error is thrown", async () => { + const tempFile = await Deno.makeTempFile(); + const importUrl = new URL("node:fs", import.meta.url); + await assertCallbackErrorUncaught({ + prelude: `import { stat } from ${JSON.stringify(importUrl)}`, + invocation: `stat(${JSON.stringify(tempFile)}, `, + async cleanup() { + await Deno.remove(tempFile); + }, + }); +}); diff --git a/tests/unit_node/_fs/_fs_symlink_test.ts b/tests/unit_node/_fs/_fs_symlink_test.ts new file mode 100644 index 000000000..4e42da293 --- /dev/null +++ b/tests/unit_node/_fs/_fs_symlink_test.ts @@ -0,0 +1,107 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { assert, assertThrows, fail } from "@test_util/std/assert/mod.ts"; +import { symlink, symlinkSync } from "node:fs"; + +Deno.test({ + name: "ASYNC: no callback function results in Error", + fn() { + assertThrows( + () => { + // @ts-expect-error Argument of type 'string' is not assignable to parameter of type 'NoParamCallback' + symlink("some/path", "some/other/path", "dir"); + }, + Error, + "No callback function supplied", + ); + }, +}); + +Deno.test({ + name: "ASYNC: create symlink point to a file", + async fn() { + const file: string = Deno.makeTempFileSync(); + const linkedFile: string = file + ".link"; + + await new Promise<void>((resolve, reject) => { + symlink(file, linkedFile, (err: Error | null) => { + if (err !== null) reject(); + else resolve(); + }); + }) + .then( + () => { + const stat = Deno.lstatSync(linkedFile); + assert(stat.isSymlink); + }, + () => { + fail("Expected to succeed"); + }, + ) + .finally(() => { + Deno.removeSync(file); + Deno.removeSync(linkedFile); + }); + }, +}); + +Deno.test({ + name: "ASYNC: create symlink point to a dir", + async fn() { + const dir: string = Deno.makeTempDirSync(); + const linkedDir: string = dir + ".link"; + + await new Promise<void>((resolve, reject) => { + symlink(dir, linkedDir, (err: Error | null) => { + if (err !== null) reject(); + else resolve(); + }); + }) + .then( + () => { + const stat = Deno.lstatSync(linkedDir); + assert(stat.isSymlink); + }, + () => { + fail("Expected to succeed"); + }, + ) + .finally(() => { + Deno.removeSync(dir); + Deno.removeSync(linkedDir); + }); + }, +}); + +Deno.test({ + name: "SYNC: create symlink point to a file", + fn() { + const file: string = Deno.makeTempFileSync(); + const linkedFile: string = file + ".link"; + + try { + symlinkSync(file, linkedFile); + const stat = Deno.lstatSync(linkedFile); + assert(stat.isSymlink); + } finally { + Deno.removeSync(file); + Deno.removeSync(linkedFile); + } + }, +}); + +Deno.test({ + name: "SYNC: create symlink point to a dir", + fn() { + const dir: string = Deno.makeTempDirSync(); + const linkedDir: string = dir + ".link"; + + try { + symlinkSync(dir, linkedDir); + const stat = Deno.lstatSync(linkedDir); + assert(stat.isSymlink); + } finally { + Deno.removeSync(dir); + Deno.removeSync(linkedDir); + } + }, +}); diff --git a/tests/unit_node/_fs/_fs_truncate_test.ts b/tests/unit_node/_fs/_fs_truncate_test.ts new file mode 100644 index 000000000..9b7a9c490 --- /dev/null +++ b/tests/unit_node/_fs/_fs_truncate_test.ts @@ -0,0 +1,95 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { assertEquals, assertThrows, fail } from "@test_util/std/assert/mod.ts"; +import { truncate, truncateSync } from "node:fs"; + +Deno.test({ + name: "ASYNC: no callback function results in Error", + fn() { + assertThrows( + () => { + // @ts-expect-error Argument of type 'number' is not assignable to parameter of type 'NoParamCallback' + truncate("some/path", 0); + }, + Error, + "No callback function supplied", + ); + }, +}); + +Deno.test({ + name: "ASYNC: truncate entire file contents", + async fn() { + const file: string = Deno.makeTempFileSync(); + await Deno.writeTextFile(file, "hello world"); + + await new Promise<void>((resolve, reject) => { + truncate(file, (err: Error | null) => { + if (err !== null) reject(); + else resolve(); + }); + }) + .then( + () => { + const fileInfo: Deno.FileInfo = Deno.lstatSync(file); + assertEquals(fileInfo.size, 0); + }, + () => { + fail("No error expected"); + }, + ) + .finally(() => Deno.removeSync(file)); + }, +}); + +Deno.test({ + name: "ASYNC: truncate file to a size of precisely len bytes", + async fn() { + const file: string = Deno.makeTempFileSync(); + await Deno.writeTextFile(file, "hello world"); + + await new Promise<void>((resolve, reject) => { + truncate(file, 3, (err: Error | null) => { + if (err !== null) reject(); + else resolve(); + }); + }) + .then( + () => { + const fileInfo: Deno.FileInfo = Deno.lstatSync(file); + assertEquals(fileInfo.size, 3); + }, + () => { + fail("No error expected"); + }, + ) + .finally(() => Deno.removeSync(file)); + }, +}); + +Deno.test({ + name: "SYNC: truncate entire file contents", + fn() { + const file: string = Deno.makeTempFileSync(); + try { + truncateSync(file); + const fileInfo: Deno.FileInfo = Deno.lstatSync(file); + assertEquals(fileInfo.size, 0); + } finally { + Deno.removeSync(file); + } + }, +}); + +Deno.test({ + name: "SYNC: truncate file to a size of precisely len bytes", + fn() { + const file: string = Deno.makeTempFileSync(); + try { + truncateSync(file, 3); + const fileInfo: Deno.FileInfo = Deno.lstatSync(file); + assertEquals(fileInfo.size, 3); + } finally { + Deno.removeSync(file); + } + }, +}); diff --git a/tests/unit_node/_fs/_fs_unlink_test.ts b/tests/unit_node/_fs/_fs_unlink_test.ts new file mode 100644 index 000000000..1bdd9ee29 --- /dev/null +++ b/tests/unit_node/_fs/_fs_unlink_test.ts @@ -0,0 +1,40 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { assertEquals, fail } from "@test_util/std/assert/mod.ts"; +import { existsSync } from "node:fs"; +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; +import { unlink, unlinkSync } from "node:fs"; + +Deno.test({ + name: "ASYNC: deleting a file", + async fn() { + const file = Deno.makeTempFileSync(); + await new Promise<void>((resolve, reject) => { + unlink(file, (err) => { + if (err) reject(err); + resolve(); + }); + }) + .then(() => assertEquals(existsSync(file), false), () => fail()) + .finally(() => { + if (existsSync(file)) Deno.removeSync(file); + }); + }, +}); + +Deno.test({ + name: "SYNC: Test deleting a file", + fn() { + const file = Deno.makeTempFileSync(); + unlinkSync(file); + assertEquals(existsSync(file), false); + }, +}); + +Deno.test("[std/node/fs] unlink callback isn't called twice if error is thrown", async () => { + const tempFile = await Deno.makeTempFile(); + const importUrl = new URL("node:fs", import.meta.url); + await assertCallbackErrorUncaught({ + prelude: `import { unlink } from ${JSON.stringify(importUrl)}`, + invocation: `unlink(${JSON.stringify(tempFile)}, `, + }); +}); diff --git a/tests/unit_node/_fs/_fs_utimes_test.ts b/tests/unit_node/_fs/_fs_utimes_test.ts new file mode 100644 index 000000000..1c6c7455e --- /dev/null +++ b/tests/unit_node/_fs/_fs_utimes_test.ts @@ -0,0 +1,100 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { assertEquals, assertThrows, fail } from "@test_util/std/assert/mod.ts"; +import { utimes, utimesSync } from "node:fs"; + +const randomDate = new Date(Date.now() + 1000); + +Deno.test({ + name: + "ASYNC: change the file system timestamps of the object referenced by path", + async fn() { + const file: string = Deno.makeTempFileSync(); + + await new Promise<void>((resolve, reject) => { + utimes(file, randomDate, randomDate, (err: Error | null) => { + if (err !== null) reject(); + else resolve(); + }); + }) + .then( + () => { + const fileInfo: Deno.FileInfo = Deno.lstatSync(file); + assertEquals(fileInfo.mtime, randomDate); + assertEquals(fileInfo.mtime, randomDate); + }, + () => { + fail("No error expected"); + }, + ) + .finally(() => Deno.removeSync(file)); + }, +}); + +Deno.test({ + name: "ASYNC: should throw error if atime is infinity", + fn() { + assertThrows( + () => { + utimes("some/path", Infinity, 0, (_err: Error | null) => {}); + }, + Error, + "invalid atime, must not be infinity or NaN", + ); + }, +}); + +Deno.test({ + name: "ASYNC: should throw error if atime is NaN", + fn() { + assertThrows( + () => { + utimes("some/path", "some string", 0, (_err: Error | null) => {}); + }, + Error, + "invalid atime, must not be infinity or NaN", + ); + }, +}); + +Deno.test({ + name: + "SYNC: change the file system timestamps of the object referenced by path", + fn() { + const file: string = Deno.makeTempFileSync(); + try { + utimesSync(file, randomDate, randomDate); + + const fileInfo: Deno.FileInfo = Deno.lstatSync(file); + + assertEquals(fileInfo.mtime, randomDate); + } finally { + Deno.removeSync(file); + } + }, +}); + +Deno.test({ + name: "SYNC: should throw error if atime is NaN", + fn() { + assertThrows( + () => { + utimesSync("some/path", "some string", 0); + }, + Error, + "invalid atime, must not be infinity or NaN", + ); + }, +}); + +Deno.test({ + name: "SYNC: should throw error if atime is Infinity", + fn() { + assertThrows( + () => { + utimesSync("some/path", Infinity, 0); + }, + Error, + "invalid atime, must not be infinity or NaN", + ); + }, +}); diff --git a/tests/unit_node/_fs/_fs_watch_test.ts b/tests/unit_node/_fs/_fs_watch_test.ts new file mode 100644 index 000000000..ffa6cac45 --- /dev/null +++ b/tests/unit_node/_fs/_fs_watch_test.ts @@ -0,0 +1,27 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { watch } from "node:fs"; +import { assertEquals } from "@test_util/std/assert/mod.ts"; + +function wait(time: number) { + return new Promise((resolve) => { + setTimeout(resolve, time); + }); +} + +Deno.test({ + name: "watching a file", + async fn() { + const file = Deno.makeTempFileSync(); + const result: Array<[string, string | null]> = []; + const watcher = watch( + file, + (eventType, filename) => result.push([eventType, filename]), + ); + await wait(100); + Deno.writeTextFileSync(file, "something"); + await wait(100); + watcher.close(); + await wait(100); + assertEquals(result.length >= 1, true); + }, +}); diff --git a/tests/unit_node/_fs/_fs_writeFile_test.ts b/tests/unit_node/_fs/_fs_writeFile_test.ts new file mode 100644 index 000000000..44f1403df --- /dev/null +++ b/tests/unit_node/_fs/_fs_writeFile_test.ts @@ -0,0 +1,345 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { + assert, + assertEquals, + assertNotEquals, + assertRejects, + assertThrows, +} from "@test_util/std/assert/mod.ts"; +import { writeFile, writeFileSync } from "node:fs"; +import * as path from "@test_util/std/path/mod.ts"; + +type TextEncodings = + | "ascii" + | "utf8" + | "utf-8" + | "utf16le" + | "ucs2" + | "ucs-2" + | "base64" + | "latin1" + | "hex"; + +const moduleDir = path.dirname(path.fromFileUrl(import.meta.url)); +const testDataDir = path.resolve(moduleDir, "testdata"); +const decoder = new TextDecoder("utf-8"); + +Deno.test("Callback must be a function error", function fn() { + assertThrows( + () => { + // @ts-expect-error Type '"made-up-encoding"' is not assignable to type + writeFile("some/path", "some data", "utf8"); + }, + TypeError, + "Callback must be a function.", + ); +}); + +Deno.test("Invalid encoding results in error()", function testEncodingErrors() { + assertThrows( + () => { + // @ts-expect-error Type '"made-up-encoding"' is not assignable to type + writeFile("some/path", "some data", "made-up-encoding", () => {}); + }, + Error, + `The value "made-up-encoding" is invalid for option "encoding"`, + ); + + assertThrows( + () => { + // @ts-expect-error Type '"made-up-encoding"' is not assignable to type + writeFileSync("some/path", "some data", "made-up-encoding"); + }, + Error, + `The value "made-up-encoding" is invalid for option "encoding"`, + ); + + assertThrows( + () => { + writeFile( + "some/path", + "some data", + { + // @ts-expect-error Type '"made-up-encoding"' is not assignable to type + encoding: "made-up-encoding", + }, + () => {}, + ); + }, + Error, + `The value "made-up-encoding" is invalid for option "encoding"`, + ); + + assertThrows( + () => { + writeFileSync("some/path", "some data", { + // @ts-expect-error Type '"made-up-encoding"' is not assignable to type + encoding: "made-up-encoding", + }); + }, + Error, + `The value "made-up-encoding" is invalid for option "encoding"`, + ); +}); + +Deno.test( + "Unsupported encoding results in error()", + function testUnsupportedEncoding() { + assertThrows( + () => { + writeFile("some/path", "some data", "utf16le", () => {}); + }, + Error, + `Not implemented: "utf16le" encoding`, + ); + + assertThrows( + () => { + writeFileSync("some/path", "some data", "utf16le"); + }, + Error, + `Not implemented: "utf16le" encoding`, + ); + }, +); + +Deno.test( + "Data is written to correct rid", + async function testCorrectWriteUsingRid() { + const tempFile: string = await Deno.makeTempFile(); + using file = await Deno.open(tempFile, { + create: true, + write: true, + read: true, + }); + + await new Promise<void>((resolve, reject) => { + writeFile(file.rid, "hello world", (err) => { + if (err) return reject(err); + resolve(); + }); + }); + + const data = await Deno.readFile(tempFile); + await Deno.remove(tempFile); + assertEquals(decoder.decode(data), "hello world"); + }, +); + +Deno.test( + "Data is written to correct file", + async function testCorrectWriteUsingPath() { + const res = await new Promise((resolve) => { + writeFile("_fs_writeFile_test_file.txt", "hello world", resolve); + }); + + const data = await Deno.readFile("_fs_writeFile_test_file.txt"); + await Deno.remove("_fs_writeFile_test_file.txt"); + assertEquals(res, null); + assertEquals(decoder.decode(data), "hello world"); + }, +); + +Deno.test( + "Data is written to correct file encodings", + async function testCorrectWriteUsingDifferentEncodings() { + const encodings = [ + ["hex", "68656c6c6f20776f726c64"], + ["HEX", "68656c6c6f20776f726c64"], + ["base64", "aGVsbG8gd29ybGQ="], + ["BASE64", "aGVsbG8gd29ybGQ="], + ["utf8", "hello world"], + ["utf-8", "hello world"], + ]; + + for (const [encoding, value] of encodings) { + const res = await new Promise((resolve) => { + writeFile( + "_fs_writeFile_test_file.txt", + value, + encoding as TextEncodings, + resolve, + ); + }); + + const data = await Deno.readFile("_fs_writeFile_test_file.txt"); + await Deno.remove("_fs_writeFile_test_file.txt"); + assertEquals(res, null); + assertEquals(decoder.decode(data), "hello world"); + } + }, +); + +Deno.test("Path can be an URL", async function testCorrectWriteUsingURL() { + const url = new URL( + Deno.build.os === "windows" + ? "file:///" + + path + .join(testDataDir, "_fs_writeFile_test_file_url.txt") + .replace(/\\/g, "/") + : "file://" + path.join(testDataDir, "_fs_writeFile_test_file_url.txt"), + ); + const filePath = path.fromFileUrl(url); + const res = await new Promise((resolve) => { + writeFile(url, "hello world", resolve); + }); + assert(res === null); + + const data = await Deno.readFile(filePath); + await Deno.remove(filePath); + assertEquals(res, null); + assertEquals(decoder.decode(data), "hello world"); +}); + +Deno.test("Mode is correctly set", async function testCorrectFileMode() { + if (Deno.build.os === "windows") return; + const filename = "_fs_writeFile_test_file.txt"; + + const res = await new Promise((resolve) => { + writeFile(filename, "hello world", { mode: 0o777 }, resolve); + }); + + const fileInfo = await Deno.stat(filename); + await Deno.remove(filename); + assertEquals(res, null); + assert(fileInfo && fileInfo.mode); + assertEquals(fileInfo.mode & 0o777, 0o777); +}); + +Deno.test( + "Mode is not set when rid is passed", + async function testCorrectFileModeRid() { + if (Deno.build.os === "windows") return; + + const filename: string = await Deno.makeTempFile(); + using file = await Deno.open(filename, { + create: true, + write: true, + read: true, + }); + + await new Promise<void>((resolve, reject) => { + writeFile(file.rid, "hello world", { mode: 0o777 }, (err) => { + if (err) return reject(err); + resolve(); + }); + }); + + const fileInfo = await Deno.stat(filename); + await Deno.remove(filename); + assert(fileInfo.mode); + assertNotEquals(fileInfo.mode & 0o777, 0o777); + }, +); + +Deno.test( + "Is cancellable with an AbortSignal", + async function testIsCancellableWithAbortSignal() { + const tempFile: string = await Deno.makeTempFile(); + const controller = new AbortController(); + // The "as any" is necessary due to https://github.com/denoland/deno/issues/19527 + // deno-lint-ignore no-explicit-any + const signal = controller.signal as any; + + const writeFilePromise = new Promise<void>((resolve, reject) => { + writeFile(tempFile, "hello world", { signal }, (err) => { + if (err) return reject(err); + resolve(); + }); + }); + controller.abort(); + + await assertRejects( + () => writeFilePromise, + "AbortError", + ); + + Deno.removeSync(tempFile); + }, +); + +Deno.test( + "Data is written synchronously to correct rid", + function testCorrectWriteSyncUsingRid() { + const tempFile: string = Deno.makeTempFileSync(); + using file = Deno.openSync(tempFile, { + create: true, + write: true, + read: true, + }); + + writeFileSync(file.rid, "hello world"); + + const data = Deno.readFileSync(tempFile); + Deno.removeSync(tempFile); + assertEquals(decoder.decode(data), "hello world"); + }, +); + +Deno.test( + "Data is written to correct file encodings", + function testCorrectWriteSyncUsingDifferentEncodings() { + const encodings = [ + ["hex", "68656c6c6f20776f726c64"], + ["HEX", "68656c6c6f20776f726c64"], + ["base64", "aGVsbG8gd29ybGQ="], + ["BASE64", "aGVsbG8gd29ybGQ="], + ["utf8", "hello world"], + ["utf-8", "hello world"], + ]; + + for (const [encoding, value] of encodings) { + const file = "_fs_writeFileSync_test_file"; + writeFileSync(file, value, encoding as TextEncodings); + + const data = Deno.readFileSync(file); + Deno.removeSync(file); + assertEquals(decoder.decode(data), "hello world"); + } + }, +); + +Deno.test( + "Data is written synchronously to correct file", + function testCorrectWriteSyncUsingPath() { + const file = "_fs_writeFileSync_test_file"; + + writeFileSync(file, "hello world"); + + const data = Deno.readFileSync(file); + Deno.removeSync(file); + assertEquals(decoder.decode(data), "hello world"); + }, +); + +Deno.test("sync: Path can be an URL", function testCorrectWriteSyncUsingURL() { + const filePath = path.join( + testDataDir, + "_fs_writeFileSync_test_file_url.txt", + ); + const url = new URL( + Deno.build.os === "windows" + ? "file:///" + filePath.replace(/\\/g, "/") + : "file://" + filePath, + ); + writeFileSync(url, "hello world"); + + const data = Deno.readFileSync(filePath); + Deno.removeSync(filePath); + assertEquals(decoder.decode(data), "hello world"); +}); + +Deno.test( + "Mode is correctly set when writing synchronously", + function testCorrectFileModeSync() { + if (Deno.build.os === "windows") return; + const filename = "_fs_writeFileSync_test_file.txt"; + + writeFileSync(filename, "hello world", { mode: 0o777 }); + + const fileInfo = Deno.statSync(filename); + Deno.removeSync(filename); + assert(fileInfo && fileInfo.mode); + assertEquals(fileInfo.mode & 0o777, 0o777); + }, +); diff --git a/tests/unit_node/_fs/_fs_write_test.ts b/tests/unit_node/_fs/_fs_write_test.ts new file mode 100644 index 000000000..7e75f321f --- /dev/null +++ b/tests/unit_node/_fs/_fs_write_test.ts @@ -0,0 +1,51 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { write, writeSync } from "node:fs"; +import { assertEquals } from "@test_util/std/assert/mod.ts"; +import { Buffer } from "node:buffer"; + +const decoder = new TextDecoder("utf-8"); + +Deno.test({ + name: "Data is written to the file with the correct length", + async fn() { + const tempFile: string = await Deno.makeTempFile(); + using file = await Deno.open(tempFile, { + create: true, + write: true, + read: true, + }); + const buffer = Buffer.from("hello world"); + const bytesWrite = await new Promise((resolve, reject) => { + write(file.rid, buffer, 0, 5, (err: unknown, nwritten: number) => { + if (err) return reject(err); + resolve(nwritten); + }); + }); + + const data = await Deno.readFile(tempFile); + await Deno.remove(tempFile); + + assertEquals(bytesWrite, 5); + assertEquals(decoder.decode(data), "hello"); + }, +}); + +Deno.test({ + name: "Data is written synchronously to the file with the correct length", + fn() { + const tempFile: string = Deno.makeTempFileSync(); + using file = Deno.openSync(tempFile, { + create: true, + write: true, + read: true, + }); + const buffer = Buffer.from("hello world"); + const bytesWrite = writeSync(file.rid, buffer, 0, 5); + + const data = Deno.readFileSync(tempFile); + Deno.removeSync(tempFile); + + assertEquals(bytesWrite, 5); + assertEquals(decoder.decode(data), "hello"); + }, +}); diff --git a/tests/unit_node/_fs/testdata/hello.txt b/tests/unit_node/_fs/testdata/hello.txt new file mode 100644 index 000000000..95d09f2b1 --- /dev/null +++ b/tests/unit_node/_fs/testdata/hello.txt @@ -0,0 +1 @@ +hello world
\ No newline at end of file diff --git a/tests/unit_node/_test_utils.ts b/tests/unit_node/_test_utils.ts new file mode 100644 index 000000000..3942cf0a9 --- /dev/null +++ b/tests/unit_node/_test_utils.ts @@ -0,0 +1,40 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import { assert, assertStringIncludes } from "@test_util/std/assert/mod.ts"; + +/** Asserts that an error thrown in a callback will not be wrongly caught. */ +export async function assertCallbackErrorUncaught( + { prelude, invocation, cleanup }: { + /** Any code which needs to run before the actual invocation (notably, any import statements). */ + prelude?: string; + /** + * The start of the invocation of the function, e.g. `open("foo.txt", `. + * The callback will be added after it. + */ + invocation: string; + /** Called after the subprocess is finished but before running the assertions, e.g. to clean up created files. */ + cleanup?: () => Promise<void> | void; + }, +) { + // Since the error has to be uncaught, and that will kill the Deno process, + // the only way to test this is to spawn a subprocess. + const p = new Deno.Command(Deno.execPath(), { + args: [ + "eval", + "--unstable", + `${prelude ?? ""} + + ${invocation}(err) => { + // If the bug is present and the callback is called again with an error, + // don't throw another error, so if the subprocess fails we know it had the correct behaviour. + if (!err) throw new Error("success"); + });`, + ], + stderr: "piped", + }); + const { stderr, success } = await p.output(); + const error = new TextDecoder().decode(stderr); + await cleanup?.(); + assert(!success); + assertStringIncludes(error, "Error: success"); +} diff --git a/tests/unit_node/assertion_error_test.ts b/tests/unit_node/assertion_error_test.ts new file mode 100644 index 000000000..b61baee93 --- /dev/null +++ b/tests/unit_node/assertion_error_test.ts @@ -0,0 +1,66 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { stripColor } from "@test_util/std/fmt/colors.ts"; +import { assert, assertStrictEquals } from "@test_util/std/assert/mod.ts"; +import { AssertionError } from "node:assert"; + +Deno.test({ + name: "construct AssertionError() with given message", + fn() { + const err = new AssertionError( + { + message: "answer", + actual: "42", + expected: "42", + operator: "notStrictEqual", + }, + ); + assertStrictEquals(err.name, "AssertionError"); + assertStrictEquals(err.message, "answer"); + assertStrictEquals(err.generatedMessage, false); + assertStrictEquals(err.code, "ERR_ASSERTION"); + assertStrictEquals(err.actual, "42"); + assertStrictEquals(err.expected, "42"); + assertStrictEquals(err.operator, "notStrictEqual"); + }, +}); + +Deno.test({ + name: "construct AssertionError() with generated message", + fn() { + const err = new AssertionError( + { actual: 1, expected: 2, operator: "equal" }, + ); + assertStrictEquals(err.name, "AssertionError"); + assertStrictEquals(stripColor(err.message), "1 equal 2"); + assertStrictEquals(err.generatedMessage, true); + assertStrictEquals(err.code, "ERR_ASSERTION"); + assertStrictEquals(err.actual, 1); + assertStrictEquals(err.expected, 2); + assertStrictEquals(err.operator, "equal"); + }, +}); + +Deno.test({ + name: "construct AssertionError() with stackStartFn", + fn: function stackStartFn() { + const expected = /node/; + const err = new AssertionError({ + actual: "deno", + expected, + operator: "match", + stackStartFn, + }); + assertStrictEquals(err.name, "AssertionError"); + assertStrictEquals(stripColor(err.message), `'deno' match /node/`); + assertStrictEquals(err.generatedMessage, true); + assertStrictEquals(err.code, "ERR_ASSERTION"); + assertStrictEquals(err.actual, "deno"); + assertStrictEquals(err.expected, expected); + assertStrictEquals(err.operator, "match"); + assert(err.stack, "error should have a stack"); + assert( + !err.stack?.includes("stackStartFn"), + "stackStartFn() should not present in stack trace", + ); + }, +}); diff --git a/tests/unit_node/async_hooks_test.ts b/tests/unit_node/async_hooks_test.ts new file mode 100644 index 000000000..1d0910d10 --- /dev/null +++ b/tests/unit_node/async_hooks_test.ts @@ -0,0 +1,79 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { AsyncLocalStorage, AsyncResource } from "node:async_hooks"; +import { assert, assertEquals } from "@test_util/std/assert/mod.ts"; + +Deno.test(async function foo() { + const asyncLocalStorage = new AsyncLocalStorage(); + + const out: string[] = []; + function logWithId(msg: string) { + const id = asyncLocalStorage.getStore(); + out.push(`${id !== undefined ? id : "-"}: ${msg}`); + } + + async function exec() { + logWithId("start"); + await new Promise((resolve) => setTimeout(resolve, 100)); + logWithId("finish"); + } + + for (const foo of [1, 2, 3]) { + asyncLocalStorage.run(foo, exec); + } + + await new Promise((resolve) => setTimeout(resolve, 500)); + + assertEquals(out, [ + "1: start", + "2: start", + "3: start", + "1: finish", + "2: finish", + "3: finish", + ]); +}); + +Deno.test(async function bar() { + let differentScopeDone = false; + const als = new AsyncLocalStorage(); + const ac = new AbortController(); + const server = Deno.serve({ + signal: ac.signal, + port: 4000, + }, () => { + const differentScope = als.run(123, () => + AsyncResource.bind(() => { + differentScopeDone = true; + })); + return als.run("Hello World", async () => { + // differentScope is attached to a different async context, so + // it will see a different value for als.getStore() (123) + setTimeout(differentScope, 5); + // Some simulated async delay. + await new Promise((res) => setTimeout(res, 10)); + return new Response(als.getStore() as string); // "Hello World" + }); + }); + + const res = await fetch("http://localhost:4000"); + assertEquals(await res.text(), "Hello World"); + ac.abort(); + await server.finished; + assert(differentScopeDone); +}); + +Deno.test(async function nested() { + const als = new AsyncLocalStorage(); + const deferred = Promise.withResolvers(); + const deferred1 = Promise.withResolvers(); + + als.run(null, () => { + als.run({ x: 1 }, () => { + deferred.resolve(als.getStore()); + }); + deferred1.resolve(als.getStore()); + }); + + assertEquals(await deferred.promise, { x: 1 }); + assertEquals(await deferred1.promise, null); +}); diff --git a/tests/unit_node/buffer_test.ts b/tests/unit_node/buffer_test.ts new file mode 100644 index 000000000..af83c9ada --- /dev/null +++ b/tests/unit_node/buffer_test.ts @@ -0,0 +1,650 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { Buffer } from "node:buffer"; +import { assertEquals, assertThrows } from "@test_util/std/assert/mod.ts"; + +Deno.test({ + name: "[node/buffer] alloc fails if size is not a number", + fn() { + const invalidSizes = [{}, "1", "foo", []]; + + for (const size of invalidSizes) { + assertThrows( + () => { + // deno-lint-ignore ban-ts-comment + // @ts-expect-error + Buffer.alloc(size); + }, + TypeError, + '"size" argument must be of type number', + "should throw on non-number size", + ); + } + }, +}); + +Deno.test({ + name: "[node/buffer] alloc allocates a buffer with the expected size", + fn() { + const buffer: Buffer = Buffer.alloc(1); + assertEquals(buffer.length, 1, "Buffer size should be 1"); + assertEquals(buffer[0], 0, "Content should be filled with 0"); + }, +}); + +Deno.test({ + name: "[node/buffer] alloc(0) creates an empty buffer", + fn() { + const buffer: Buffer = Buffer.alloc(0); + assertEquals(buffer.length, 0, "Buffer size should be 0"); + }, +}); + +Deno.test({ + name: "[node/buffer] allocUnsafe allocates a buffer with the expected size", + fn() { + const buffer: Buffer = Buffer.allocUnsafe(1); + assertEquals(buffer.length, 1, "Buffer size should be 1"); + }, +}); + +Deno.test({ + name: "[node/buffer] allocUnsafe(0) creates an empty buffer", + fn() { + const buffer: Buffer = Buffer.allocUnsafe(0); + assertEquals(buffer.length, 0, "Buffer size should be 0"); + }, +}); + +Deno.test({ + name: "[node/buffer] alloc filled correctly with integer", + fn() { + const buffer: Buffer = Buffer.alloc(3, 5); + assertEquals(buffer, Buffer.from([5, 5, 5])); + }, +}); + +Deno.test({ + name: "[node/buffer] alloc filled correctly with single character", + fn() { + assertEquals(Buffer.alloc(5, "a"), Buffer.from([97, 97, 97, 97, 97])); + }, +}); + +Deno.test({ + name: "[node/buffer] alloc filled correctly with base64 string", + fn() { + assertEquals( + Buffer.alloc(11, "aGVsbG8gd29ybGQ=", "base64"), + Buffer.from([104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]), + ); + }, +}); + +Deno.test({ + name: "[node/buffer] alloc filled correctly with hex string", + fn() { + assertEquals( + Buffer.alloc(4, "64656e6f", "hex"), + Buffer.from([100, 101, 110, 111]), + ); + }, +}); + +Deno.test({ + name: + "[node/buffer] alloc filled correctly with hex string smaller than alloc size", + fn() { + assertEquals( + Buffer.alloc(13, "64656e6f", "hex").toString(), + "denodenodenod", + ); + }, +}); + +Deno.test({ + name: + "[node/buffer] alloc filled correctly with Uint8Array smaller than alloc size", + fn() { + // todo(fbaltor): remove this 'any' when @types/node fixes https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/65831 + // deno-lint-ignore no-explicit-any + const arr: any = new Uint8Array([100, 101]); + assertEquals( + Buffer.alloc(7, arr), + Buffer.from([100, 101, 100, 101, 100, 101, 100]), + ); + assertEquals( + Buffer.alloc(6, arr), + Buffer.from([100, 101, 100, 101, 100, 101]), + ); + }, +}); + +Deno.test({ + name: + "[node/buffer] alloc filled correctly with Uint8Array bigger than alloc size", + fn() { + assertEquals( + // todo(fbaltor): remove this 'any' when @types/node fixes https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/65831 + // deno-lint-ignore no-explicit-any + Buffer.alloc(1, new Uint8Array([100, 101]) as any), + Buffer.from([100]), + ); + }, +}); + +Deno.test({ + name: "[node/buffer] alloc filled correctly with Buffer", + fn() { + assertEquals( + Buffer.alloc(6, Buffer.from([100, 101])), + Buffer.from([100, 101, 100, 101, 100, 101]), + ); + assertEquals( + Buffer.alloc(7, Buffer.from([100, 101])), + Buffer.from([100, 101, 100, 101, 100, 101, 100]), + ); + }, +}); + +// tests from: +// https://github.com/nodejs/node/blob/56dbe466fdbc598baea3bfce289bf52b97b8b8f7/test/parallel/test-buffer-bytelength.js#L70 +Deno.test({ + name: "[node/buffer] Byte length is the expected for strings", + fn() { + // Special case: zero length string + assertEquals(Buffer.byteLength("", "ascii"), 0); + // deno-lint-ignore no-explicit-any + assertEquals(Buffer.byteLength("", "HeX" as any), 0); + + // utf8 + assertEquals(Buffer.byteLength("∑éllö wørl∂!", "utf-8"), 19); + assertEquals(Buffer.byteLength("κλμνξο", "utf8"), 12); + assertEquals(Buffer.byteLength("挵挶挷挸挹", "utf-8"), 15); + // deno-lint-ignore no-explicit-any + assertEquals(Buffer.byteLength("𠝹𠱓𠱸", "UTF8" as any), 12); + // Without an encoding, utf8 should be assumed + assertEquals(Buffer.byteLength("hey there"), 9); + assertEquals(Buffer.byteLength("𠱸挶νξ#xx :)"), 17); + // deno-lint-ignore no-explicit-any + assertEquals(Buffer.byteLength("hello world", "" as any), 11); + // It should also be assumed with unrecognized encoding + // deno-lint-ignore no-explicit-any + assertEquals(Buffer.byteLength("hello world", "abc" as any), 11); + // deno-lint-ignore no-explicit-any + assertEquals(Buffer.byteLength("ßœ∑≈", "unkn0wn enc0ding" as any), 10); + + // base64 + assertEquals(Buffer.byteLength("aGVsbG8gd29ybGQ=", "base64"), 11); + // deno-lint-ignore no-explicit-any + assertEquals(Buffer.byteLength("aGVsbG8gd29ybGQ=", "BASE64" as any), 11); + assertEquals(Buffer.byteLength("bm9kZS5qcyByb2NrcyE=", "base64"), 14); + assertEquals(Buffer.byteLength("aGkk", "base64"), 3); + assertEquals( + Buffer.byteLength("bHNrZGZsa3NqZmtsc2xrZmFqc2RsZmtqcw==", "base64"), + 25, + ); + // special padding + assertEquals(Buffer.byteLength("aaa=", "base64"), 2); + assertEquals(Buffer.byteLength("aaaa==", "base64"), 3); + + assertEquals(Buffer.byteLength("Il était tué"), 14); + assertEquals(Buffer.byteLength("Il était tué", "utf8"), 14); + + ["ascii", "latin1", "binary"] + .reduce((es: string[], e: string) => es.concat(e, e.toUpperCase()), []) + .forEach((encoding: string) => { + // deno-lint-ignore no-explicit-any + assertEquals(Buffer.byteLength("Il était tué", encoding as any), 12); + }); + + ["ucs2", "ucs-2", "utf16le", "utf-16le"] + .reduce((es: string[], e: string) => es.concat(e, e.toUpperCase()), []) + .forEach((encoding: string) => { + // deno-lint-ignore no-explicit-any + assertEquals(Buffer.byteLength("Il était tué", encoding as any), 24); + }); + }, +}); + +Deno.test({ + name: "[node/buffer] Byte length is the expected one for non-strings", + fn() { + assertEquals( + Buffer.byteLength(Buffer.alloc(0)), + Buffer.alloc(0).byteLength, + "Byte length differs on buffers", + ); + }, +}); + +Deno.test({ + name: "[node/buffer] Two Buffers are concatenated", + fn() { + const data1 = [1, 2, 3]; + const data2 = [4, 5, 6]; + + const buffer1 = Buffer.from(data1); + const buffer2 = Buffer.from(data2); + + const resultBuffer = Buffer.concat([buffer1, buffer2]); + const expectedBuffer = Buffer.from([...data1, ...data2]); + assertEquals(resultBuffer, expectedBuffer); + }, +}); + +Deno.test({ + name: "[node/buffer] A single buffer concatenates and return the same buffer", + fn() { + const buffer1 = Buffer.alloc(1); + const resultBuffer = Buffer.concat([buffer1]); + assertEquals(resultBuffer.length, 1, "Buffer length should be 1"); + }, +}); + +Deno.test({ + name: "[node/buffer] No buffers concat returns an empty buffer", + fn() { + const resultBuffer = Buffer.concat([]); + assertEquals(resultBuffer.length, 0, "Buffer length should be 0"); + }, +}); + +Deno.test({ + name: "[node/buffer] Buffer concat respects totalLength parameter", + fn() { + const maxLength1 = 10; + const buffer1 = Buffer.alloc(2); + const buffer2 = Buffer.alloc(2); + assertEquals( + Buffer.concat([buffer1, buffer2], maxLength1).length, + maxLength1, + ); + + const maxLength2 = 3; + const buffer3 = Buffer.alloc(2); + const buffer4 = Buffer.alloc(2); + assertEquals( + Buffer.concat([buffer3, buffer4], maxLength2).length, + maxLength2, + ); + }, +}); + +Deno.test({ + name: "[node/buffer] Buffer 8 bit unsigned integers", + fn() { + const buffer = Buffer.from([0xff, 0x2a, 0x2a, 0x2a]); + assertEquals(buffer.readUInt8(0), 255); + assertEquals(buffer.readUInt8(1), 42); + assertEquals(buffer.readUInt8(2), 42); + assertEquals(buffer.readUInt8(3), 42); + }, +}); + +Deno.test({ + name: "[node/buffer] Buffer 16 bit unsigned integers", + fn() { + const buffer = Buffer.from([0x00, 0x2a, 0x42, 0x3f]); + assertEquals(buffer.readUInt16BE(0), 0x2a); + assertEquals(buffer.readUInt16BE(1), 0x2a42); + assertEquals(buffer.readUInt16BE(2), 0x423f); + assertEquals(buffer.readUInt16LE(0), 0x2a00); + assertEquals(buffer.readUInt16LE(1), 0x422a); + assertEquals(buffer.readUInt16LE(2), 0x3f42); + + buffer[0] = 0xfe; + buffer[1] = 0xfe; + assertEquals(buffer.readUInt16BE(0), 0xfefe); + assertEquals(buffer.readUInt16LE(0), 0xfefe); + }, +}); + +Deno.test({ + name: "[node/buffer] Buffer 32 bit unsigned integers", + fn() { + const buffer = Buffer.from([0x32, 0x65, 0x42, 0x56, 0x23, 0xff]); + assertEquals(buffer.readUInt32BE(0), 0x32654256); + assertEquals(buffer.readUInt32BE(1), 0x65425623); + assertEquals(buffer.readUInt32BE(2), 0x425623ff); + assertEquals(buffer.readUInt32LE(0), 0x56426532); + assertEquals(buffer.readUInt32LE(1), 0x23564265); + assertEquals(buffer.readUInt32LE(2), 0xff235642); + }, +}); + +Deno.test({ + name: "[node/buffer] Buffer readUIntBE", + fn() { + const buffer = Buffer.from([ + 0x01, + 0x02, + 0x03, + 0x04, + 0x05, + 0x06, + 0x07, + 0x08, + ]); + assertEquals(buffer.readUIntBE(0, 1), 0x01); + assertEquals(buffer.readUIntBE(0, 2), 0x0102); + assertEquals(buffer.readUIntBE(0, 4), 0x01020304); + }, +}); + +Deno.test({ + name: "[node/buffer] Buffer readUIntLE", + fn() { + const buffer = Buffer.from([ + 0x01, + 0x02, + 0x03, + 0x04, + 0x05, + 0x06, + 0x07, + 0x08, + ]); + assertEquals(buffer.readUIntLE(0, 1), 0x01); + assertEquals(buffer.readUIntLE(0, 2), 0x0201); + assertEquals(buffer.readUIntLE(0, 4), 0x04030201); + }, +}); + +Deno.test({ + name: "[node/buffer] Buffer copy works as expected", + fn() { + const data1 = new Uint8Array([1, 2, 3]); + const data2 = new Uint8Array([4, 5, 6]); + + const buffer1 = Buffer.from(data1); + const buffer2 = Buffer.from(data2); + + //Mutates data_1 + data1.set(data2); + //Mutates buffer_1 + buffer2.copy(buffer1); + + assertEquals( + Buffer.from(data1), + buffer1, + ); + }, +}); + +Deno.test({ + name: "[node/buffer] Buffer copy respects the starting point for copy", + fn() { + const buffer1 = Buffer.from([1, 2, 3]); + const buffer2 = Buffer.alloc(8); + + buffer1.copy(buffer2, 5); + + const expected = Buffer.from([0, 0, 0, 0, 0, 1, 2, 3]); + + assertEquals( + buffer2, + expected, + ); + }, +}); + +Deno.test({ + name: + "[node/buffer] Buffer copy doesn't throw on offset but copies until offset reached", + fn() { + const buffer1 = Buffer.from([1, 2, 3]); + const buffer2 = Buffer.alloc(8); + + const writtenBytes1 = buffer1.copy(buffer2, 6); + + assertEquals( + writtenBytes1, + 2, + ); + + assertEquals( + buffer2, + Buffer.from([0, 0, 0, 0, 0, 0, 1, 2]), + ); + + const buffer3 = Buffer.from([1, 2, 3]); + const buffer4 = Buffer.alloc(8); + + const writtenBytes2 = buffer3.copy(buffer4, 8); + + assertEquals( + writtenBytes2, + 0, + ); + + assertEquals( + buffer4, + Buffer.from([0, 0, 0, 0, 0, 0, 0, 0]), + ); + }, +}); + +Deno.test({ + name: "[node/buffer] Buffer from string creates a Buffer", + fn() { + const buffer: Buffer = Buffer.from("test"); + assertEquals(buffer.length, 4, "Buffer length should be 4"); + assertEquals( + buffer.toString(), + "test", + "Buffer to string should recover the string", + ); + }, +}); + +Deno.test({ + name: "[node/buffer] Buffer from string hex", + fn() { + for (const encoding of ["hex", "HEX"]) { + const buffer: Buffer = Buffer.from( + "7468697320697320612074c3a97374", + // deno-lint-ignore no-explicit-any + encoding as any, + ); + assertEquals(buffer.length, 15, "Buffer length should be 15"); + assertEquals( + buffer.toString(), + "this is a tést", + "Buffer to string should recover the string", + ); + } + }, +}); + +Deno.test({ + name: "[node/buffer] Buffer from string base64", + fn() { + for (const encoding of ["base64", "BASE64"]) { + const buffer: Buffer = Buffer.from( + "dGhpcyBpcyBhIHTDqXN0", + // deno-lint-ignore no-explicit-any + encoding as any, + ); + assertEquals(buffer.length, 15, "Buffer length should be 15"); + assertEquals( + buffer.toString(), + "this is a tést", + "Buffer to string should recover the string", + ); + } + }, +}); + +Deno.test({ + name: "[node/buffer] Buffer to string base64", + fn() { + for (const encoding of ["base64", "BASE64"]) { + const buffer: Buffer = Buffer.from("deno land"); + assertEquals( + // deno-lint-ignore no-explicit-any + buffer.toString(encoding as any), + "ZGVubyBsYW5k", + "Buffer to string should recover the string in base64", + ); + } + const b64 = "dGhpcyBpcyBhIHTDqXN0"; + assertEquals(Buffer.from(b64, "base64").toString("base64"), b64); + }, +}); + +Deno.test({ + name: "[node/buffer] Buffer to string hex", + fn() { + for (const encoding of ["hex", "HEX"]) { + const buffer: Buffer = Buffer.from("deno land"); + assertEquals( + // deno-lint-ignore no-explicit-any + buffer.toString(encoding as any), + "64656e6f206c616e64", + "Buffer to string should recover the string", + ); + } + const hex = "64656e6f206c616e64"; + assertEquals(Buffer.from(hex, "hex").toString("hex"), hex); + }, +}); + +Deno.test({ + name: "[node/buffer] Buffer from string invalid encoding", + fn() { + const defaultToUtf8Encodings = [null, 5, {}, true, false, ""]; + const invalidEncodings = ["deno", "base645"]; + + for (const encoding of defaultToUtf8Encodings) { + // deno-lint-ignore no-explicit-any + assertEquals(Buffer.from("yes", encoding as any).toString(), "yes"); + } + + for (const encoding of invalidEncodings) { + assertThrows( + () => { + // deno-lint-ignore no-explicit-any + Buffer.from("yes", encoding as any); + }, + TypeError, + `Unknown encoding: ${encoding}`, + ); + } + }, +}); + +Deno.test({ + name: "[node/buffer] Buffer from another buffer creates a Buffer", + fn() { + const buffer: Buffer = Buffer.from(Buffer.from("test")); + assertEquals(buffer.length, 4, "Buffer length should be 4"); + assertEquals( + buffer.toString(), + "test", + "Buffer to string should recover the string", + ); + }, +}); + +Deno.test({ + name: "[node/buffer] isBuffer returns true if the object is a buffer", + fn() { + assertEquals(Buffer.isBuffer(Buffer.from("test")), true); + }, +}); + +Deno.test({ + name: "[node/buffer] isBuffer returns false if the object is not a buffer", + fn() { + assertEquals(Buffer.isBuffer({ test: 3 }), false); + assertEquals(Buffer.isBuffer(new Uint8Array()), false); + }, +}); + +Deno.test({ + name: "[node/buffer] Buffer toJSON", + fn() { + assertEquals( + JSON.stringify(Buffer.from("deno")), + '{"type":"Buffer","data":[100,101,110,111]}', + ); + }, +}); + +Deno.test({ + name: "[node/buffer] slice does not create a copy", + fn() { + const buf = Buffer.from("ceno"); + // This method is not compatible with the Uint8Array.prototype.slice() + const slice = buf.slice(); + slice[0]++; + assertEquals(slice.toString(), "deno"); + }, +}); + +Deno.test({ + name: "[node/buffer] slice with infinity returns empty buffer", + fn() { + const buf = Buffer.from([1, 2, 3, 4, 5]); + assertEquals(buf.slice(Infinity).length, 0); + }, +}); + +Deno.test({ + name: "[node/buffer] isEncoding returns true for valid encodings", + fn() { + [ + "hex", + "HEX", + "HeX", + "utf8", + "utf-8", + "ascii", + "latin1", + "binary", + "base64", + "BASE64", + "BASe64", + "ucs2", + "ucs-2", + "utf16le", + "utf-16le", + ].forEach((enc) => { + assertEquals(Buffer.isEncoding(enc), true); + }); + }, +}); + +Deno.test({ + name: "[node/buffer] isEncoding returns false for invalid encodings", + fn() { + [ + "utf9", + "utf-7", + "Unicode-FTW", + "new gnu gun", + false, + NaN, + {}, + Infinity, + [], + 1, + 0, + -1, + ].forEach((enc) => { + // @ts-expect-error This deliberately ignores the type constraint + assertEquals(Buffer.isEncoding(enc), false); + }); + }, +}); + +Deno.test({ + name: + "[node/buffer] utf8Write handle missing optional length argument (https://github.com/denoland/deno_std/issues/2046)", + fn() { + const buf = Buffer.alloc(8); + // @ts-expect-error Buffer.prototype.utf8Write is an undocumented API + assertEquals(buf.utf8Write("abc", 0), 3); + assertEquals([...buf], [0x61, 0x62, 0x63, 0, 0, 0, 0, 0]); + }, +}); diff --git a/tests/unit_node/child_process_test.ts b/tests/unit_node/child_process_test.ts new file mode 100644 index 000000000..5314d66e7 --- /dev/null +++ b/tests/unit_node/child_process_test.ts @@ -0,0 +1,773 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import CP from "node:child_process"; +import { Buffer } from "node:buffer"; +import { + assert, + assertEquals, + assertExists, + assertNotStrictEquals, + assertStrictEquals, + assertStringIncludes, +} from "@test_util/std/assert/mod.ts"; +import * as path from "@test_util/std/path/mod.ts"; + +const { spawn, spawnSync, execFile, execFileSync, ChildProcess } = CP; + +function withTimeout<T>( + timeoutInMS = 10_000, +): ReturnType<typeof Promise.withResolvers<T>> { + const deferred = Promise.withResolvers<T>(); + const timer = setTimeout(() => { + deferred.reject("Timeout"); + }, timeoutInMS); + deferred.promise.then(() => { + clearTimeout(timer); + }); + return deferred; +} + +// TODO(uki00a): Once Node.js's `parallel/test-child-process-spawn-error.js` works, this test case should be removed. +Deno.test("[node/child_process spawn] The 'error' event is emitted when no binary is found", async () => { + const deferred = withTimeout<void>(); + const childProcess = spawn("no-such-cmd"); + childProcess.on("error", (_err: Error) => { + // TODO(@bartlomieju) Assert an error message. + deferred.resolve(); + }); + await deferred.promise; +}); + +Deno.test("[node/child_process spawn] The 'exit' event is emitted with an exit code after the child process ends", async () => { + const deferred = withTimeout<void>(); + const childProcess = spawn(Deno.execPath(), ["--help"], { + env: { NO_COLOR: "true" }, + }); + try { + let exitCode = null; + childProcess.on("exit", (code: number) => { + deferred.resolve(); + exitCode = code; + }); + await deferred.promise; + assertStrictEquals(exitCode, 0); + assertStrictEquals(childProcess.exitCode, exitCode); + } finally { + childProcess.kill(); + childProcess.stdout?.destroy(); + childProcess.stderr?.destroy(); + } +}); + +Deno.test("[node/child_process disconnect] the method exists", async () => { + const deferred = withTimeout<void>(); + const childProcess = spawn(Deno.execPath(), ["--help"], { + env: { NO_COLOR: "true" }, + }); + try { + childProcess.disconnect(); + childProcess.on("exit", () => { + deferred.resolve(); + }); + await deferred.promise; + } finally { + childProcess.kill(); + childProcess.stdout?.destroy(); + childProcess.stderr?.destroy(); + } +}); + +Deno.test({ + name: "[node/child_process spawn] Verify that stdin and stdout work", + fn: async () => { + const deferred = withTimeout<void>(); + const childProcess = spawn(Deno.execPath(), ["fmt", "-"], { + env: { NO_COLOR: "true" }, + stdio: ["pipe", "pipe"], + }); + try { + assert(childProcess.stdin, "stdin should be defined"); + assert(childProcess.stdout, "stdout should be defined"); + let data = ""; + childProcess.stdout.on("data", (chunk) => { + data += chunk; + }); + childProcess.stdin.write(" console.log('hello')", "utf-8"); + childProcess.stdin.end(); + childProcess.on("close", () => { + deferred.resolve(); + }); + await deferred.promise; + assertStrictEquals(data, `console.log("hello");\n`); + } finally { + childProcess.kill(); + } + }, +}); + +Deno.test({ + name: "[node/child_process spawn] stdin and stdout with binary data", + fn: async () => { + const deferred = withTimeout<void>(); + const p = path.join( + path.dirname(path.fromFileUrl(import.meta.url)), + "./testdata/binary_stdio.js", + ); + const childProcess = spawn(Deno.execPath(), ["run", p], { + env: { NO_COLOR: "true" }, + stdio: ["pipe", "pipe"], + }); + try { + assert(childProcess.stdin, "stdin should be defined"); + assert(childProcess.stdout, "stdout should be defined"); + let data: Buffer; + childProcess.stdout.on("data", (chunk) => { + data = chunk; + }); + const buffer = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); + childProcess.stdin.write(buffer); + childProcess.stdin.end(); + childProcess.on("close", () => { + deferred.resolve(); + }); + await deferred.promise; + assertEquals(new Uint8Array(data!), buffer); + } finally { + childProcess.kill(); + } + }, +}); + +async function spawnAndGetEnvValue( + inputValue: string | number | boolean, +): Promise<string> { + const deferred = withTimeout<string>(); + const env = spawn( + `"${Deno.execPath()}" eval -p "Deno.env.toObject().BAZ"`, + { + env: { BAZ: String(inputValue), NO_COLOR: "true" }, + shell: true, + }, + ); + try { + let envOutput = ""; + + assert(env.stdout); + env.on("error", (err: Error) => deferred.reject(err)); + env.stdout.on("data", (data) => { + envOutput += data; + }); + env.on("close", () => { + deferred.resolve(envOutput.trim()); + }); + return await deferred.promise; + } finally { + env.kill(); + } +} + +Deno.test({ + ignore: Deno.build.os === "windows", + name: + "[node/child_process spawn] Verify that environment values can be numbers", + async fn() { + const envOutputValue = await spawnAndGetEnvValue(42); + assertStrictEquals(envOutputValue, "42"); + }, +}); + +Deno.test({ + ignore: Deno.build.os === "windows", + name: + "[node/child_process spawn] Verify that environment values can be booleans", + async fn() { + const envOutputValue = await spawnAndGetEnvValue(false); + assertStrictEquals(envOutputValue, "false"); + }, +}); + +/* Start of ported part */ +// Copyright Joyent and Node contributors. All rights reserved. MIT license. +// Ported from Node 15.5.1 + +// TODO(uki00a): Remove this case once Node's `parallel/test-child-process-spawn-event.js` works. +Deno.test("[child_process spawn] 'spawn' event", async () => { + const timeout = withTimeout<void>(); + const subprocess = spawn(Deno.execPath(), ["eval", "console.log('ok')"]); + + let didSpawn = false; + subprocess.on("spawn", function () { + didSpawn = true; + }); + + function mustNotBeCalled() { + timeout.reject(new Error("function should not have been called")); + } + + const promises = [] as Promise<void>[]; + function mustBeCalledAfterSpawn() { + const deferred = Promise.withResolvers<void>(); + promises.push(deferred.promise); + return () => { + if (didSpawn) { + deferred.resolve(); + } else { + deferred.reject( + new Error("function should be called after the 'spawn' event"), + ); + } + }; + } + + subprocess.on("error", mustNotBeCalled); + subprocess.stdout!.on("data", mustBeCalledAfterSpawn()); + subprocess.stdout!.on("end", mustBeCalledAfterSpawn()); + subprocess.stdout!.on("close", mustBeCalledAfterSpawn()); + subprocess.stderr!.on("data", mustNotBeCalled); + subprocess.stderr!.on("end", mustBeCalledAfterSpawn()); + subprocess.stderr!.on("close", mustBeCalledAfterSpawn()); + subprocess.on("exit", mustBeCalledAfterSpawn()); + subprocess.on("close", mustBeCalledAfterSpawn()); + + try { + await Promise.race([Promise.all(promises), timeout.promise]); + timeout.resolve(); + } finally { + subprocess.kill(); + } +}); + +// TODO(uki00a): Remove this case once Node's `parallel/test-child-process-spawn-shell.js` works. +Deno.test("[child_process spawn] Verify that a shell is executed", async () => { + const deferred = withTimeout<void>(); + const doesNotExist = spawn("does-not-exist", { shell: true }); + try { + assertNotStrictEquals(doesNotExist.spawnfile, "does-not-exist"); + doesNotExist.on("error", () => { + deferred.reject("The 'error' event must not be emitted."); + }); + doesNotExist.on("exit", (code: number, signal: null) => { + assertStrictEquals(signal, null); + + if (Deno.build.os === "windows") { + assertStrictEquals(code, 1); // Exit code of cmd.exe + } else { + assertStrictEquals(code, 127); // Exit code of /bin/sh }); + } + + deferred.resolve(); + }); + await deferred.promise; + } finally { + doesNotExist.kill(); + doesNotExist.stdout?.destroy(); + doesNotExist.stderr?.destroy(); + } +}); + +// TODO(uki00a): Remove this case once Node's `parallel/test-child-process-spawn-shell.js` works. +Deno.test({ + ignore: Deno.build.os === "windows", + name: "[node/child_process spawn] Verify that passing arguments works", + async fn() { + const deferred = withTimeout<void>(); + const echo = spawn("echo", ["foo"], { + shell: true, + }); + let echoOutput = ""; + + try { + assertStrictEquals( + echo.spawnargs[echo.spawnargs.length - 1].replace(/"/g, ""), + "echo foo", + ); + assert(echo.stdout); + echo.stdout.on("data", (data) => { + echoOutput += data; + }); + echo.on("close", () => { + assertStrictEquals(echoOutput.trim(), "foo"); + deferred.resolve(); + }); + await deferred.promise; + } finally { + echo.kill(); + } + }, +}); + +// TODO(uki00a): Remove this case once Node's `parallel/test-child-process-spawn-shell.js` works. +Deno.test({ + ignore: Deno.build.os === "windows", + name: "[node/child_process spawn] Verity that shell features can be used", + async fn() { + const deferred = withTimeout<void>(); + const cmd = "echo bar | cat"; + const command = spawn(cmd, { + shell: true, + }); + try { + let commandOutput = ""; + + assert(command.stdout); + command.stdout.on("data", (data) => { + commandOutput += data; + }); + + command.on("close", () => { + assertStrictEquals(commandOutput.trim(), "bar"); + deferred.resolve(); + }); + + await deferred.promise; + } finally { + command.kill(); + } + }, +}); + +// TODO(uki00a): Remove this case once Node's `parallel/test-child-process-spawn-shell.js` works. +Deno.test({ + ignore: Deno.build.os === "windows", + name: + "[node/child_process spawn] Verity that environment is properly inherited", + async fn() { + const deferred = withTimeout<void>(); + const env = spawn( + `"${Deno.execPath()}" eval -p "Deno.env.toObject().BAZ"`, + { + env: { BAZ: "buzz", NO_COLOR: "true" }, + shell: true, + }, + ); + try { + let envOutput = ""; + + assert(env.stdout); + env.on("error", (err: Error) => deferred.reject(err)); + env.stdout.on("data", (data) => { + envOutput += data; + }); + env.on("close", () => { + assertStrictEquals(envOutput.trim(), "buzz"); + deferred.resolve(); + }); + await deferred.promise; + } finally { + env.kill(); + } + }, +}); +/* End of ported part */ + +Deno.test({ + name: "[node/child_process execFile] Get stdout as a string", + async fn() { + let child: unknown; + const script = path.join( + path.dirname(path.fromFileUrl(import.meta.url)), + "./testdata/exec_file_text_output.js", + ); + const promise = new Promise<string | null>((resolve, reject) => { + child = execFile(Deno.execPath(), ["run", script], (err, stdout) => { + if (err) reject(err); + else if (stdout) resolve(stdout as string); + else resolve(null); + }); + }); + try { + const stdout = await promise; + assertEquals(stdout, "Hello World!\n"); + } finally { + if (child instanceof ChildProcess) { + child.kill(); + } + } + }, +}); + +Deno.test({ + name: "[node/child_process execFile] Get stdout as a buffer", + async fn() { + let child: unknown; + const script = path.join( + path.dirname(path.fromFileUrl(import.meta.url)), + "./testdata/exec_file_text_output.js", + ); + const promise = new Promise<Buffer | null>((resolve, reject) => { + child = execFile( + Deno.execPath(), + ["run", script], + { encoding: "buffer" }, + (err, stdout) => { + if (err) reject(err); + else if (stdout) resolve(stdout as Buffer); + else resolve(null); + }, + ); + }); + try { + const stdout = await promise; + assert(Buffer.isBuffer(stdout)); + assertEquals(stdout.toString("utf8"), "Hello World!\n"); + } finally { + if (child instanceof ChildProcess) { + child.kill(); + } + } + }, +}); + +Deno.test({ + name: "[node/child_process execFile] Get stderr", + async fn() { + let child: unknown; + const script = path.join( + path.dirname(path.fromFileUrl(import.meta.url)), + "./testdata/exec_file_text_error.js", + ); + const promise = new Promise< + { err: Error | null; stderr?: string | Buffer } + >((resolve) => { + child = execFile(Deno.execPath(), ["run", script], (err, _, stderr) => { + resolve({ err, stderr }); + }); + }); + try { + const { err, stderr } = await promise; + if (child instanceof ChildProcess) { + assertEquals(child.exitCode, 1); + assertEquals(stderr, "yikes!\n"); + } else { + throw err; + } + } finally { + if (child instanceof ChildProcess) { + child.kill(); + } + } + }, +}); + +Deno.test({ + name: "[node/child_process execFile] Exceed given maxBuffer limit", + async fn() { + let child: unknown; + const script = path.join( + path.dirname(path.fromFileUrl(import.meta.url)), + "./testdata/exec_file_text_error.js", + ); + const promise = new Promise< + { err: Error | null; stderr?: string | Buffer } + >((resolve) => { + child = execFile(Deno.execPath(), ["run", script], { + encoding: "buffer", + maxBuffer: 3, + }, (err, _, stderr) => { + resolve({ err, stderr }); + }); + }); + try { + const { err, stderr } = await promise; + if (child instanceof ChildProcess) { + assert(err); + assertEquals( + // deno-lint-ignore no-explicit-any + (err as any).code, + "ERR_CHILD_PROCESS_STDIO_MAXBUFFER", + ); + assertEquals(err.message, "stderr maxBuffer length exceeded"); + assertEquals((stderr as Buffer).toString("utf8"), "yik"); + } else { + throw err; + } + } finally { + if (child instanceof ChildProcess) { + child.kill(); + } + } + }, +}); + +Deno.test({ + name: "[node/child_process] ChildProcess.kill()", + async fn() { + const script = path.join( + path.dirname(path.fromFileUrl(import.meta.url)), + "./testdata/infinite_loop.js", + ); + const childProcess = spawn(Deno.execPath(), ["run", script]); + const p = withTimeout<void>(); + const pStdout = withTimeout<void>(); + const pStderr = withTimeout<void>(); + childProcess.on("exit", () => p.resolve()); + childProcess.stdout.on("close", () => pStdout.resolve()); + childProcess.stderr.on("close", () => pStderr.resolve()); + childProcess.kill("SIGKILL"); + await p.promise; + await pStdout.promise; + await pStderr.promise; + assert(childProcess.killed); + assertEquals(childProcess.signalCode, "SIGKILL"); + assertExists(childProcess.exitCode); + }, +}); + +Deno.test({ + ignore: true, + name: "[node/child_process] ChildProcess.unref()", + async fn() { + const script = path.join( + path.dirname(path.fromFileUrl(import.meta.url)), + "testdata", + "child_process_unref.js", + ); + const childProcess = spawn(Deno.execPath(), [ + "run", + "-A", + "--unstable", + script, + ]); + const deferred = Promise.withResolvers<void>(); + childProcess.on("exit", () => deferred.resolve()); + await deferred.promise; + }, +}); + +Deno.test({ + ignore: true, + name: "[node/child_process] child_process.fork", + async fn() { + const testdataDir = path.join( + path.dirname(path.fromFileUrl(import.meta.url)), + "testdata", + ); + const script = path.join( + testdataDir, + "node_modules", + "foo", + "index.js", + ); + const p = Promise.withResolvers<void>(); + const cp = CP.fork(script, [], { cwd: testdataDir, stdio: "pipe" }); + let output = ""; + cp.on("close", () => p.resolve()); + cp.stdout?.on("data", (data) => { + output += data; + }); + await p.promise; + assertEquals(output, "foo\ntrue\ntrue\ntrue\n"); + }, +}); + +Deno.test("[node/child_process execFileSync] 'inherit' stdout and stderr", () => { + execFileSync(Deno.execPath(), ["--help"], { stdio: "inherit" }); +}); + +Deno.test( + "[node/child_process spawn] supports windowsVerbatimArguments option", + { ignore: Deno.build.os !== "windows" }, + async () => { + const cmdFinished = Promise.withResolvers<void>(); + let output = ""; + const cp = spawn("cmd", ["/d", "/s", "/c", '"deno ^"--version^""'], { + stdio: "pipe", + windowsVerbatimArguments: true, + }); + cp.on("close", () => cmdFinished.resolve()); + cp.stdout?.on("data", (data) => { + output += data; + }); + await cmdFinished.promise; + assertStringIncludes(output, "deno"); + assertStringIncludes(output, "v8"); + assertStringIncludes(output, "typescript"); + }, +); + +Deno.test( + "[node/child_process spawn] supports stdio array option", + async () => { + const cmdFinished = Promise.withResolvers<void>(); + let output = ""; + const script = path.join( + path.dirname(path.fromFileUrl(import.meta.url)), + "testdata", + "child_process_stdio.js", + ); + const cp = spawn(Deno.execPath(), ["run", "-A", script]); + cp.stdout?.on("data", (data) => { + output += data; + }); + cp.on("close", () => cmdFinished.resolve()); + await cmdFinished.promise; + + assertStringIncludes(output, "foo"); + assertStringIncludes(output, "close"); + }, +); + +Deno.test( + "[node/child_process spawn] supports stdio [0, 1, 2] option", + async () => { + const cmdFinished = Promise.withResolvers<void>(); + let output = ""; + const script = path.join( + path.dirname(path.fromFileUrl(import.meta.url)), + "testdata", + "child_process_stdio_012.js", + ); + const cp = spawn(Deno.execPath(), ["run", "-A", script]); + cp.stdout?.on("data", (data) => { + output += data; + }); + cp.on("close", () => cmdFinished.resolve()); + await cmdFinished.promise; + + assertStringIncludes(output, "foo"); + assertStringIncludes(output, "close"); + }, +); + +Deno.test({ + name: "[node/child_process spawn] supports SIGIOT signal", + ignore: Deno.build.os === "windows", + async fn() { + // Note: attempting to kill Deno with SIGABRT causes the process to zombify on certain OSX builds + // eg: 22.5.0 Darwin Kernel Version 22.5.0: Mon Apr 24 20:53:19 PDT 2023; root:xnu-8796.121.2~5/RELEASE_ARM64_T6020 arm64 + // M2 Pro running Ventura 13.4 + + // Spawn an infinite cat + const cp = spawn("cat", ["-"]); + const p = withTimeout<void>(); + const pStdout = withTimeout<void>(); + const pStderr = withTimeout<void>(); + cp.on("exit", () => p.resolve()); + cp.stdout.on("close", () => pStdout.resolve()); + cp.stderr.on("close", () => pStderr.resolve()); + cp.kill("SIGIOT"); + await p.promise; + await pStdout.promise; + await pStderr.promise; + assert(cp.killed); + assertEquals(cp.signalCode, "SIGIOT"); + }, +}); + +// Regression test for https://github.com/denoland/deno/issues/20373 +Deno.test(async function undefinedValueInEnvVar() { + const deferred = withTimeout<string>(); + const env = spawn( + `"${Deno.execPath()}" eval -p "Deno.env.toObject().BAZ"`, + { + env: { + BAZ: "BAZ", + NO_COLOR: "true", + UNDEFINED_ENV: undefined, + // deno-lint-ignore no-explicit-any + NULL_ENV: null as any, + }, + shell: true, + }, + ); + try { + let envOutput = ""; + + assert(env.stdout); + env.on("error", (err: Error) => deferred.reject(err)); + env.stdout.on("data", (data) => { + envOutput += data; + }); + env.on("close", () => { + deferred.resolve(envOutput.trim()); + }); + await deferred.promise; + } finally { + env.kill(); + } + const value = await deferred.promise; + assertEquals(value, "BAZ"); +}); + +// Regression test for https://github.com/denoland/deno/issues/20373 +Deno.test(function spawnSyncUndefinedValueInEnvVar() { + const ret = spawnSync( + `"${Deno.execPath()}" eval -p "Deno.env.toObject().BAZ"`, + { + env: { + BAZ: "BAZ", + NO_COLOR: "true", + UNDEFINED_ENV: undefined, + // deno-lint-ignore no-explicit-any + NULL_ENV: null as any, + }, + shell: true, + }, + ); + + assertEquals(ret.status, 0); + assertEquals(ret.stdout.toString("utf-8").trim(), "BAZ"); +}); + +Deno.test(function spawnSyncStdioUndefined() { + const ret = spawnSync( + `"${Deno.execPath()}" eval "console.log('hello');console.error('world')"`, + { + stdio: [undefined, undefined, undefined], + shell: true, + }, + ); + + assertEquals(ret.status, 0); + assertEquals(ret.stdout.toString("utf-8").trim(), "hello"); + assertEquals(ret.stderr.toString("utf-8").trim(), "world"); +}); + +Deno.test(function spawnSyncExitNonZero() { + const ret = spawnSync( + `"${Deno.execPath()}" eval "Deno.exit(22)"`, + { shell: true }, + ); + + assertEquals(ret.status, 22); +}); + +// https://github.com/denoland/deno/issues/21630 +Deno.test(async function forkIpcKillDoesNotHang() { + const testdataDir = path.join( + path.dirname(path.fromFileUrl(import.meta.url)), + "testdata", + ); + const script = path.join( + testdataDir, + "node_modules", + "foo", + "index.js", + ); + const p = Promise.withResolvers<void>(); + const cp = CP.fork(script, [], { + cwd: testdataDir, + stdio: ["inherit", "inherit", "inherit", "ipc"], + }); + cp.on("close", () => p.resolve()); + cp.kill(); + + await p.promise; +}); + +Deno.test(async function execFileWithUndefinedTimeout() { + const { promise, resolve, reject } = Promise.withResolvers<void>(); + CP.execFile( + "git", + ["-v"], + { timeout: undefined, encoding: "utf8" }, + (err) => { + if (err) { + reject(err); + return; + } + resolve(); + }, + ); + await promise; +}); diff --git a/tests/unit_node/console_test.ts b/tests/unit_node/console_test.ts new file mode 100644 index 000000000..bf6f667f2 --- /dev/null +++ b/tests/unit_node/console_test.ts @@ -0,0 +1,28 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import vm from "node:vm"; +import { stripColor } from "@test_util/std/fmt/colors.ts"; +import { assertStringIncludes } from "@test_util/std/assert/mod.ts"; + +Deno.test(function inspectCrossRealmObjects() { + assertStringIncludes( + stripColor( + Deno.inspect(vm.runInNewContext(`new Error("This is an error")`)), + ), + "Error: This is an error", + ); + assertStringIncludes( + stripColor( + Deno.inspect( + vm.runInNewContext(`new AggregateError([], "This is an error")`), + ), + ), + "AggregateError: This is an error", + ); + assertStringIncludes( + stripColor( + Deno.inspect(vm.runInNewContext(`new Date("2018-12-10T02:26:59.002Z")`)), + ), + "2018-12-10T02:26:59.002Z", + ); +}); diff --git a/tests/unit_node/crypto/crypto_cipher_gcm_test.ts b/tests/unit_node/crypto/crypto_cipher_gcm_test.ts new file mode 100644 index 000000000..b7b616546 --- /dev/null +++ b/tests/unit_node/crypto/crypto_cipher_gcm_test.ts @@ -0,0 +1,103 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import crypto from "node:crypto"; +import { Buffer } from "node:buffer"; +import testVectors128 from "./gcmEncryptExtIV128.json" assert { type: "json" }; +import testVectors256 from "./gcmEncryptExtIV256.json" assert { type: "json" }; +import { assertEquals } from "@test_util/std/assert/mod.ts"; + +const aesGcm = (bits: string, key: Uint8Array) => { + const ALGO = bits == "128" ? `aes-128-gcm` : `aes-256-gcm`; + + // encrypt returns base64-encoded ciphertext + const encrypt = ( + iv: Uint8Array, + str: string, + aad: Uint8Array, + ): [string, Buffer] => { + const cipher = crypto.createCipheriv(ALGO, key, iv); + cipher.setAAD(aad); + let enc = cipher.update(str, "base64", "base64"); + enc += cipher.final("base64"); + return [enc, cipher.getAuthTag()]; + }; + + const decrypt = ( + enc: string, + iv: Uint8Array, + aad: Uint8Array, + authTag: Uint8Array, + ) => { + const decipher = crypto.createDecipheriv(ALGO, key, iv); + decipher.setAuthTag(authTag); + decipher.setAAD(aad); + let str = decipher.update(enc, "base64", "base64"); + str += decipher.final("base64"); + + return str; + }; + + return { + encrypt, + decrypt, + }; +}; + +type TestVector = { + key: Uint8Array; + nonce: Uint8Array; + aad: Uint8Array; + plaintext: string; + ciphertext: string; + tag: Uint8Array; +}; + +for ( + // NIST CAVS vectors + const [bits, vectors] of Object.entries({ + // <https://csrc.nist.gov/Projects/cryptographic-algorithm-validation-program/CAVP-TESTING-BLOCK-CIPHER-MODES> + // + // From: `gcmEncryptExtIV128.rsp` + 128: testVectors128, + // <https://csrc.nist.gov/Projects/cryptographic-algorithm-validation-program/CAVP-TESTING-BLOCK-CIPHER-MODES> + // + // From: `gcmEncryptExtIV256.rsp` + 256: testVectors256, + }) +) { + for (let i = 0; i < vectors.length; i++) { + const rawTest = vectors[i]; + const test: TestVector = { + key: new Uint8Array(rawTest.key), + nonce: new Uint8Array(rawTest.nonce), + aad: new Uint8Array(rawTest.aad), + plaintext: Buffer.from(rawTest.plaintext).toString("base64"), + ciphertext: Buffer.from(rawTest.ciphertext).toString("base64"), + tag: new Uint8Array(rawTest.tag), + }; + + Deno.test({ + name: `aes-${bits}-gcm encrypt ${i + 1}/${vectors.length}`, + fn() { + const cipher = aesGcm(bits, test.key); + const [enc, tag] = cipher.encrypt(test.nonce, test.plaintext, test.aad); + assertEquals(enc, test.ciphertext); + assertEquals(new Uint8Array(tag), test.tag); + }, + }); + + Deno.test({ + name: `aes-${bits}-gcm decrypt ${i + 1}/${vectors.length}`, + fn() { + const cipher = aesGcm(bits, test.key); + const plaintext = cipher.decrypt( + test.ciphertext, + test.nonce, + test.aad, + test.tag, + ); + assertEquals(plaintext, test.plaintext); + }, + }); + } +} diff --git a/tests/unit_node/crypto/crypto_cipher_test.ts b/tests/unit_node/crypto/crypto_cipher_test.ts new file mode 100644 index 000000000..3da7ae3f1 --- /dev/null +++ b/tests/unit_node/crypto/crypto_cipher_test.ts @@ -0,0 +1,258 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import crypto from "node:crypto"; +import { Buffer } from "node:buffer"; +import { Readable } from "node:stream"; +import { buffer, text } from "node:stream/consumers"; +import { assertEquals, assertThrows } from "@test_util/std/assert/mod.ts"; + +const rsaPrivateKey = Deno.readTextFileSync( + new URL("../testdata/rsa_private.pem", import.meta.url), +); +const rsaPublicKey = Deno.readTextFileSync( + new URL("../testdata/rsa_public.pem", import.meta.url), +); + +const input = new TextEncoder().encode("hello world"); + +function zeros(length: number): Uint8Array { + return new Uint8Array(length); +} + +Deno.test({ + name: "rsa public encrypt and private decrypt", + fn() { + const encrypted = crypto.publicEncrypt(Buffer.from(rsaPublicKey), input); + const decrypted = crypto.privateDecrypt( + Buffer.from(rsaPrivateKey), + Buffer.from(encrypted), + ); + assertEquals(decrypted, input); + }, +}); + +Deno.test({ + name: "rsa public encrypt (options) and private decrypt", + fn() { + const encrypted = crypto.publicEncrypt( + { key: Buffer.from(rsaPublicKey) }, + input, + ); + const decrypted = crypto.privateDecrypt( + Buffer.from(rsaPrivateKey), + Buffer.from(encrypted), + ); + assertEquals(decrypted, input); + }, +}); + +Deno.test({ + name: "rsa private encrypt and private decrypt", + fn() { + const encrypted = crypto.privateEncrypt(rsaPrivateKey, input); + const decrypted = crypto.privateDecrypt( + rsaPrivateKey, + Buffer.from(encrypted), + ); + assertEquals(decrypted, input); + }, +}); + +Deno.test({ + name: "rsa public decrypt fail", + fn() { + const encrypted = crypto.publicEncrypt(rsaPublicKey, input); + assertThrows(() => + crypto.publicDecrypt(rsaPublicKey, Buffer.from(encrypted)) + ); + }, +}); + +Deno.test({ + name: "createCipheriv - multiple chunk inputs", + fn() { + const cipher = crypto.createCipheriv( + "aes-128-cbc", + new Uint8Array(16), + new Uint8Array(16), + ); + assertEquals( + cipher.update(new Uint8Array(16), undefined, "hex"), + "66e94bd4ef8a2c3b884cfa59ca342b2e", + ); + assertEquals( + cipher.update(new Uint8Array(19), undefined, "hex"), + "f795bd4a52e29ed713d313fa20e98dbc", + ); + assertEquals( + cipher.update(new Uint8Array(55), undefined, "hex"), + "a10cf66d0fddf3405370b4bf8df5bfb347c78395e0d8ae2194da0a90abc9888a94ee48f6c78fcd518a941c3896102cb1", + ); + assertEquals(cipher.final("hex"), "e11901dde4a2f99fe4efc707e48c6aed"); + }, +}); + +Deno.test({ + name: "createCipheriv - algorithms", + fn() { + const table = [ + [ + ["aes-128-cbc", 16, 16], + "66e94bd4ef8a2c3b884cfa59ca342b2ef795bd4a52e29ed713d313fa20e98dbca10cf66d0fddf3405370b4bf8df5bfb3", + "d5f65ecda64511e9d3d12206411ffd72", + ], + [ + ["aes-128-ecb", 16, 0], + "66e94bd4ef8a2c3b884cfa59ca342b2e66e94bd4ef8a2c3b884cfa59ca342b2e66e94bd4ef8a2c3b884cfa59ca342b2e", + "baf823258ca2e6994f638daa3515e986", + ], + [ + ["aes-192-ecb", 24, 0], + "aae06992acbf52a3e8f4a96ec9300bd7aae06992acbf52a3e8f4a96ec9300bd7aae06992acbf52a3e8f4a96ec9300bd7", + "2e0f33b51bb184654311ead507ea55fc", + ], + [ + ["aes-256-ecb", 32, 0], + "dc95c078a2408989ad48a21492842087dc95c078a2408989ad48a21492842087dc95c078a2408989ad48a21492842087", + "0ac1d7e8655254c6814b46753932df88", + ], + [ + ["aes256", 32, 16], + "dc95c078a2408989ad48a2149284208708c374848c228233c2b34f332bd2e9d38b70c515a6663d38cdb8e6532b266491", + "2e62607a5e8b715e4cb229a12169f2b2", + ], + [ + ["aes-256-cbc", 32, 16], + "dc95c078a2408989ad48a2149284208708c374848c228233c2b34f332bd2e9d38b70c515a6663d38cdb8e6532b266491", + "2e62607a5e8b715e4cb229a12169f2b2", + ], + ] as const; + for ( + const [[alg, keyLen, ivLen], expectedUpdate, expectedFinal] of table + ) { + const cipher = crypto.createCipheriv(alg, zeros(keyLen), zeros(ivLen)); + assertEquals(cipher.update(zeros(50), undefined, "hex"), expectedUpdate); + assertEquals(cipher.final("hex"), expectedFinal); + } + }, +}); + +Deno.test({ + name: "createCipheriv - input encoding", + fn() { + const cipher = crypto.createCipheriv( + "aes-128-cbc", + new Uint8Array(16), + new Uint8Array(16), + ); + assertEquals( + cipher.update("hello, world! hello, world!", "utf-8", "hex"), + "ca7df4d74f51b77a7440ead38343ab0f", + ); + assertEquals(cipher.final("hex"), "d0da733dec1fa61125c80a6f97e6166e"); + }, +}); + +Deno.test({ + name: "createCipheriv - transform stream", + async fn() { + const result = await buffer( + Readable.from("foo".repeat(15)).pipe(crypto.createCipheriv( + "aes-128-cbc", + new Uint8Array(16), + new Uint8Array(16), + )), + ); + // deno-fmt-ignore + assertEquals([...result], [ + 129, 19, 202, 142, 137, 51, 23, 53, 198, 33, + 214, 125, 17, 5, 128, 57, 162, 217, 220, 53, + 172, 51, 85, 113, 71, 250, 44, 156, 80, 4, + 158, 92, 185, 173, 67, 47, 255, 71, 78, 187, + 80, 206, 42, 5, 34, 104, 1, 54 + ]); + }, +}); + +Deno.test({ + name: "createDecipheriv - algorithms", + fn() { + const table = [ + [ + ["aes-128-cbc", 16, 16], + "66e94bd4ef8a2c3b884cfa59ca342b2ef795bd4a52e29ed713d313fa20e98dbca10cf66d0fddf3405370b4bf8df5bfb347c78395e0d8ae2194da0a90abc9888a94ee48f6c78fcd518a941c3896102cb1e11901dde4a2f99fe4efc707e48c6aed", + ], + [ + ["aes-128-ecb", 16, 0], + "66e94bd4ef8a2c3b884cfa59ca342b2e66e94bd4ef8a2c3b884cfa59ca342b2e66e94bd4ef8a2c3b884cfa59ca342b2e66e94bd4ef8a2c3b884cfa59ca342b2e66e94bd4ef8a2c3b884cfa59ca342b2ec29a917cbaf72fa9bc32129bb0d17663", + ], + [ + ["aes-192-ecb", 24, 0], + "aae06992acbf52a3e8f4a96ec9300bd7aae06992acbf52a3e8f4a96ec9300bd7aae06992acbf52a3e8f4a96ec9300bd7aae06992acbf52a3e8f4a96ec9300bd7aae06992acbf52a3e8f4a96ec9300bd7ab40eb56b6fc2aacf2e9254685cce891", + ], + [ + ["aes-256-ecb", 32, 0], + "dc95c078a2408989ad48a21492842087dc95c078a2408989ad48a21492842087dc95c078a2408989ad48a21492842087dc95c078a2408989ad48a21492842087dc95c078a2408989ad48a214928420877c45b49560579dd1ffc7ec626de2a968", + ], + [ + ["aes256", 32, 16], + "dc95c078a2408989ad48a2149284208708c374848c228233c2b34f332bd2e9d38b70c515a6663d38cdb8e6532b2664915d0dcc192580aee9ef8a8568193f1b44bfca557c6bab7dc79da07ffd42191b2659e6bee99cb2a6a7299f0e9a21686fc7", + ], + [ + ["aes-256-cbc", 32, 16], + "dc95c078a2408989ad48a2149284208708c374848c228233c2b34f332bd2e9d38b70c515a6663d38cdb8e6532b2664915d0dcc192580aee9ef8a8568193f1b44bfca557c6bab7dc79da07ffd42191b2659e6bee99cb2a6a7299f0e9a21686fc7", + ], + ] as const; + for ( + const [[alg, keyLen, ivLen], input] of table + ) { + const cipher = crypto.createDecipheriv(alg, zeros(keyLen), zeros(ivLen)); + assertEquals(cipher.update(input, "hex"), Buffer.alloc(80)); + assertEquals(cipher.final(), Buffer.alloc(10)); + } + }, +}); + +Deno.test({ + name: "createDecipheriv - transform stream", + async fn() { + const stream = Readable.from([ + // deno-fmt-ignore + new Uint8Array([ + 129, 19, 202, 142, 137, 51, 23, 53, 198, 33, + 214, 125, 17, 5, 128, 57, 162, 217, 220, 53, + 172, 51, 85, 113, 71, 250, 44, 156, 80, 4, + 158, 92, 185, 173, 67, 47, 255, 71, 78, 187, + 80, 206, 42, 5, 34, 104, 1, 54 + ]), + ]).pipe(crypto.createDecipheriv( + "aes-128-cbc", + new Uint8Array(16), + new Uint8Array(16), + )); + assertEquals(await text(stream), "foo".repeat(15)); + }, +}); + +Deno.test({ + name: "createCipheriv - invalid algorithm", + fn() { + assertThrows( + () => + crypto.createCipheriv("foo", new Uint8Array(16), new Uint8Array(16)), + TypeError, + "Unknown cipher", + ); + }, +}); + +Deno.test({ + name: "createDecipheriv - invalid algorithm", + fn() { + assertThrows( + () => + crypto.createDecipheriv("foo", new Uint8Array(16), new Uint8Array(16)), + TypeError, + "Unknown cipher", + ); + }, +}); diff --git a/tests/unit_node/crypto/crypto_hash_test.ts b/tests/unit_node/crypto/crypto_hash_test.ts new file mode 100644 index 000000000..ff1c9c598 --- /dev/null +++ b/tests/unit_node/crypto/crypto_hash_test.ts @@ -0,0 +1,139 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { + createHash, + createHmac, + getHashes, + randomFillSync, + randomUUID, +} from "node:crypto"; +import { Buffer } from "node:buffer"; +import { Readable } from "node:stream"; +import { assert, assertEquals } from "@test_util/std/assert/mod.ts"; + +// https://github.com/denoland/deno/issues/18140 +Deno.test({ + name: "[node/crypto] createHmac digest", + fn() { + assertEquals( + createHmac("sha256", "secret").update("hello").digest("hex"), + "88aab3ede8d3adf94d26ab90d3bafd4a2083070c3bcce9c014ee04a443847c0b", + ); + }, +}); + +Deno.test({ + name: "[node/crypto] createHash digest", + fn() { + assertEquals( + createHash("sha256").update("hello").digest("hex"), + "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824", + ); + }, +}); + +Deno.test("[node/crypto.Hash] basic usage - buffer output", () => { + const d = createHash("sha1").update("abc").update("def").digest(); + assertEquals( + d, + Buffer.from([ + 0x1f, + 0x8a, + 0xc1, + 0xf, + 0x23, + 0xc5, + 0xb5, + 0xbc, + 0x11, + 0x67, + 0xbd, + 0xa8, + 0x4b, + 0x83, + 0x3e, + 0x5c, + 0x5, + 0x7a, + 0x77, + 0xd2, + ]), + ); +}); + +Deno.test("[node/crypto.Hash] basic usage - hex output", () => { + const d = createHash("sha1").update("abc").update("def").digest("hex"); + assertEquals(d, "1f8ac10f23c5b5bc1167bda84b833e5c057a77d2"); +}); + +Deno.test("[node/crypto.Hash] basic usage - base64 output", () => { + const d = createHash("sha1").update("abc").update("def").digest("base64"); + assertEquals(d, "H4rBDyPFtbwRZ72oS4M+XAV6d9I="); +}); + +Deno.test("[node/crypto.Hash] basic usage - base64url output", () => { + const d = createHash("sha1").update("abc").update("def").digest("base64url"); + assertEquals(d, "H4rBDyPFtbwRZ72oS4M-XAV6d9I"); +}); + +Deno.test("[node/crypto.Hash] streaming usage", async () => { + const source = Readable.from(["abc", "def"]); + const hash = createHash("sha1"); + const dest = source.pipe(hash); + const result = await new Promise((resolve, _) => { + let buffer = Buffer.from([]); + dest.on("data", (data) => { + buffer = Buffer.concat([buffer, data]); + }); + dest.on("end", () => { + resolve(buffer); + }); + }); + assertEquals( + result, + Buffer.from([ + 0x1f, + 0x8a, + 0xc1, + 0xf, + 0x23, + 0xc5, + 0xb5, + 0xbc, + 0x11, + 0x67, + 0xbd, + 0xa8, + 0x4b, + 0x83, + 0x3e, + 0x5c, + 0x5, + 0x7a, + 0x77, + 0xd2, + ]), + ); +}); + +Deno.test("[node/crypto.getHashes]", () => { + for (const algorithm of getHashes()) { + const d = createHash(algorithm).update("abc").digest(); + assert(d instanceof Buffer); + assert(d.length > 0); + } +}); + +Deno.test("[node/crypto.getRandomUUID] works the same way as Web Crypto API", () => { + assertEquals(randomUUID().length, crypto.randomUUID().length); + assertEquals(typeof randomUUID(), typeof crypto.randomUUID()); +}); + +Deno.test("[node/crypto.randomFillSync] supported arguments", () => { + const buf = new Uint8Array(10); + + assert(randomFillSync(buf)); + assert(randomFillSync(buf, 0)); + // @ts-ignore: arraybuffer arguments are valid. + assert(randomFillSync(buf.buffer)); + assert(randomFillSync(new DataView(buf.buffer))); +}); diff --git a/tests/unit_node/crypto/crypto_key_test.ts b/tests/unit_node/crypto/crypto_key_test.ts new file mode 100644 index 000000000..8d1b24b21 --- /dev/null +++ b/tests/unit_node/crypto/crypto_key_test.ts @@ -0,0 +1,233 @@ +// deno-lint-ignore-file no-explicit-any + +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { + createPrivateKey, + createSecretKey, + generateKeyPair, + generateKeyPairSync, + KeyObject, + randomBytes, +} from "node:crypto"; +import { promisify } from "node:util"; +import { Buffer } from "node:buffer"; +import { assertEquals, assertThrows } from "@test_util/std/assert/mod.ts"; +import { createHmac } from "node:crypto"; + +const RUN_SLOW_TESTS = Deno.env.get("SLOW_TESTS") === "1"; + +const generateKeyPairAsync = promisify( + ( + type: any, + options: any, + callback: ( + err: Error | null, + key: { publicKey: KeyObject; privateKey: KeyObject }, + ) => void, + ) => + generateKeyPair( + type, + options, + (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => { + callback(err, { publicKey, privateKey }); + }, + ), +); + +Deno.test({ + name: "create secret key", + fn() { + const key = createSecretKey(Buffer.alloc(0)); + assertEquals(key.type, "secret"); + assertEquals(key.asymmetricKeyType, undefined); + assertEquals(key.symmetricKeySize, 0); + }, +}); + +Deno.test({ + name: "export secret key", + fn() { + const material = Buffer.from(randomBytes(32)); + const key = createSecretKey(material); + assertEquals(Buffer.from(key.export()), material); + }, +}); + +Deno.test({ + name: "export jwk secret key", + fn() { + const material = Buffer.from("secret"); + const key = createSecretKey(material); + assertEquals(key.export({ format: "jwk" }), { + kty: "oct", + k: "c2VjcmV0", + }); + }, +}); + +Deno.test({ + name: "createHmac with secret key", + fn() { + const key = createSecretKey(Buffer.from("secret")); + assertEquals( + createHmac("sha256", key).update("hello").digest().toString("hex"), + "88aab3ede8d3adf94d26ab90d3bafd4a2083070c3bcce9c014ee04a443847c0b", + ); + }, +}); + +const modulusLengths = RUN_SLOW_TESTS ? [2048, 3072] : [2048]; + +for (const type of ["rsa", "rsa-pss", "dsa"]) { + for (const modulusLength of modulusLengths) { + Deno.test({ + name: `generate ${type} key ${modulusLength}`, + fn() { + const { publicKey, privateKey } = generateKeyPairSync(type as any, { + modulusLength, + }); + + assertEquals(publicKey.type, "public"); + assertEquals(privateKey.type, "private"); + }, + }); + + Deno.test({ + name: `generate ${type} key async ${modulusLength}`, + async fn() { + const x = await generateKeyPairAsync(type as any, { + modulusLength, + }); + const { publicKey, privateKey } = x; + assertEquals(publicKey.type, "public"); + assertEquals(privateKey.type, "private"); + }, + }); + } +} + +for (const namedCurve of ["P-384", "P-256"]) { + Deno.test({ + name: `generate ec key ${namedCurve}`, + fn() { + const { publicKey, privateKey } = generateKeyPairSync("ec", { + namedCurve, + }); + + assertEquals(publicKey.type, "public"); + assertEquals(privateKey.type, "private"); + }, + }); + + Deno.test({ + name: `generate ec key ${namedCurve} async`, + async fn() { + const { publicKey, privateKey } = await generateKeyPairAsync("ec", { + namedCurve, + }); + + assertEquals(publicKey.type, "public"); + assertEquals(privateKey.type, "private"); + }, + }); + + Deno.test({ + name: `generate ec key ${namedCurve} paramEncoding=explicit fails`, + fn() { + assertThrows(() => { + // @ts-ignore: @types/node is broken? + generateKeyPairSync("ec", { + namedCurve, + paramEncoding: "explicit", + }); + }); + }, + }); +} + +for ( + const groupName of ["modp5", "modp14", "modp15", "modp16", "modp17", "modp18"] +) { + Deno.test({ + name: `generate dh key ${groupName}`, + fn() { + // @ts-ignore: @types/node is broken? + const { publicKey, privateKey } = generateKeyPairSync("dh", { + group: groupName, + }); + + assertEquals(publicKey.type, "public"); + assertEquals(privateKey.type, "private"); + }, + }); + + Deno.test({ + name: `generate dh key ${groupName} async`, + async fn() { + // @ts-ignore: @types/node is broken? + const { publicKey, privateKey } = await generateKeyPairAsync("dh", { + group: groupName, + }); + + assertEquals(publicKey.type, "public"); + assertEquals(privateKey.type, "private"); + }, + }); +} + +const primeLengths = RUN_SLOW_TESTS ? [1024, 2048, 4096] : [1024]; + +for (const primeLength of primeLengths) { + Deno.test({ + name: `generate dh key ${primeLength}`, + fn() { + // @ts-ignore: @types/node is broken? + const { publicKey, privateKey } = generateKeyPairSync("dh", { + primeLength, + generator: 2, + }); + + assertEquals(publicKey.type, "public"); + assertEquals(privateKey.type, "private"); + }, + }); + + Deno.test({ + name: `generate dh key ${primeLength} async`, + async fn() { + // @ts-ignore: @types/node is broken? + const { publicKey, privateKey } = await generateKeyPairAsync("dh", { + primeLength, + generator: 2, + }); + + assertEquals(publicKey.type, "public"); + assertEquals(privateKey.type, "private"); + }, + }); +} + +const rsaPrivateKey = Deno.readTextFileSync( + new URL("../testdata/rsa_private.pem", import.meta.url), +); + +Deno.test("createPrivateKey rsa", function () { + const key = createPrivateKey(rsaPrivateKey); + assertEquals(key.type, "private"); + assertEquals(key.asymmetricKeyType, "rsa"); + assertEquals(key.asymmetricKeyDetails?.modulusLength, 2048); + assertEquals(key.asymmetricKeyDetails?.publicExponent, 65537n); +}); + +// openssl ecparam -name secp256r1 -genkey -noout -out a.pem +// openssl pkcs8 -topk8 -nocrypt -in a.pem -out b.pem +const ecPrivateKey = Deno.readTextFileSync( + new URL("./ec_private_secp256r1.pem", import.meta.url), +); + +Deno.test("createPrivateKey ec", function () { + const key = createPrivateKey(ecPrivateKey); + assertEquals(key.type, "private"); + assertEquals(key.asymmetricKeyType, "ec"); + assertEquals(key.asymmetricKeyDetails?.namedCurve, "p256"); +}); diff --git a/tests/unit_node/crypto/crypto_sign_test.ts b/tests/unit_node/crypto/crypto_sign_test.ts new file mode 100644 index 000000000..287b54cc1 --- /dev/null +++ b/tests/unit_node/crypto/crypto_sign_test.ts @@ -0,0 +1,129 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import { assert, assertEquals } from "@test_util/std/testing/asserts.ts"; +import { createSign, createVerify, sign, verify } from "node:crypto"; +import { Buffer } from "node:buffer"; + +const rsaPrivatePem = Buffer.from( + await Deno.readFile( + new URL("../testdata/rsa_private.pem", import.meta.url), + ), +); +const rsaPrivatePkcs1Pem = Buffer.from( + await Deno.readFile( + new URL("../testdata/rsa_private_pkcs1.pem", import.meta.url), + ), +); +const rsaPublicPem = Buffer.from( + await Deno.readFile( + new URL("../testdata/rsa_public.pem", import.meta.url), + ), +); + +const table = [ + { + algorithms: ["sha224", "RSA-SHA224"], + signature: + "7ad162b288bd7f4ba9b8a31295ad4136d143a5fd11eb99a72379dc9b53e3e8b5c1b7c9dd8a3864a1f626d921e550c48056982bd8fe7e75333885311b5515de1ecbbfcc6a1dd930f422dff87bfceb7eb38882ac6b4fd9dea9efd462776775976e81b1d677f8db41f5ac8686abfa9838069125be939c59e404aa50550872d84befb8b5f6ce2dd051c62a8ba268f876b6f17a27af43b79938222e4ab8b90c4f5540d0f8b02508ef3e68279d685746956b924f00c92438b7981a3cfcb1e2a97305402d381ea62aeaa803f8707961bc3e10a258352e210772e9846ca4024e3dc0a956a50d6db1c03d2943826cc98c6f36d7bafacf1c94b6c438c7664c300a3be172b1", + }, + { + algorithms: ["sha256", "RSA-SHA256"], + signature: + "080313284d7398e1e0e27f6e44f198ceecedddc801e81af63a867d9245ad744e29018099c9ac3c27061c33cabfe27af1db38f44bac09cdcd2c4ab3b00a2a3020f68368f2239db5f911a2dbb7ea2dee322ca7d26d0c88d197482ca4aa1c29ac87b9e6c20075dc974ae71d2d76d2a5b2a15bd541033519465c3aea815cc73b0f1c3ffeedcfb93d6788416623789f86786870d23e86b982ab0df157d7a596097bd3cca3e752f3f47eff4b83754296868b52bc8ff741492dc8a401fe6dc035569e45d1fa1a71c8988d3aadce68fb1bf5c3e756c586af20c8e75c037436ff4c8389e6ce9d943ef7e2566977b84577272181fcec403077cc29e7db1166fff900b36a1d", + }, + { + algorithms: ["sha384", "RSA-SHA384"], + signature: + "2f77a5b7ac0168efd652c30ecb082075f3de30629e9c1f51b7e7e671f24b5c3a2606bb72159a217438220fc7aaba887d4b817e3f43fe0cc8f840747368df8cd65ec760c21a3f9296d01caedc80a335030e31d31ac451277fc4bcc1679c168b2c3185dfee21286514113c080af5238a61a677b03777344f476f25053108588aa6bdc02a6138c6b59a20de4d11e3d668482f17e748e75747f83c0512206283acfc64ed0ad963dddc9ec24589cfd459ee806b8e0e67b93cea16651e967762a5deef890f438ffb9db39247469289db06e2ed7fe262aa1df4ab9607e5b5219a17ddc9694283a61bf8643f58fd702f2c5d3b2d53dc7f36bb5e96461174d376950d6d19", + }, + { + algorithms: ["sha512", "RSA-SHA512"], + signature: + "072e20a433f255ab2f7e5e9ce69255d5c6d7c15a36af75c8389b9672c41abc6a9532fbd057d9d64270bb2483d3c9923f8f419fba4b59b838dcda82a1322009d245c06e2802a74febaea9cebc0b7f46f8761331c5f52ffb650245b5aefefcc604f209b44f6560fe45370cb239d236622e5f72fbb45377f08a0c733e16a8f15830897679ad4349d2e2e5e50a99796820302f4f47881ed444aede56a6d3330b71acaefc4218ae2e4a3bdfbb0c9432ffc5e5bac8c168278b2205d68a5d6905ccbb91282d519c11eccca52d42c86787de492b2a89679dce98cd14c37b0c183af8427e7a1ec86b1ed3f9b5bebf83f1ef81eb18748e69c716a0f263a8598fe627158647", + }, +]; + +const data = Buffer.from("some data to sign"); + +Deno.test({ + name: + "crypto.Sign|sign - RSA PEM with SHA224, SHA256, SHA384, SHA512 digests", + fn() { + for (const testCase of table) { + for (const algorithm of testCase.algorithms) { + assertEquals( + createSign(algorithm) + .update(data) + .sign(rsaPrivatePem, "hex"), + testCase.signature, + ); + assertEquals( + sign(algorithm, data, rsaPrivatePem), + Buffer.from(testCase.signature, "hex"), + ); + } + } + }, +}); + +Deno.test({ + name: + "crypto.Verify|verify - RSA PEM with SHA224, SHA256, SHA384, SHA512 digests", + fn() { + for (const testCase of table) { + for (const algorithm of testCase.algorithms) { + assert( + createVerify(algorithm).update(data).verify( + rsaPublicPem, + testCase.signature, + "hex", + ), + ); + assert( + verify( + algorithm, + data, + rsaPublicPem, + Buffer.from(testCase.signature, "hex"), + ), + ); + } + } + }, +}); + +Deno.test({ + name: "crypto.createPrivateKey|sign - RSA PEM", + fn() { + for (const testCase of table) { + for (const algorithm of testCase.algorithms) { + assertEquals( + createSign(algorithm).update(data).sign(rsaPrivatePem, "hex"), + testCase.signature, + ); + assertEquals( + sign(algorithm, data, rsaPrivatePem), + Buffer.from(testCase.signature, "hex"), + ); + } + } + }, +}); + +Deno.test({ + name: "crypto.createPrivateKey|sign - RSA PKCS1 PEM", + fn() { + for (const testCase of table) { + for (const algorithm of testCase.algorithms) { + assertEquals( + createSign(algorithm).update(data).sign(rsaPrivatePkcs1Pem, "hex"), + testCase.signature, + ); + assertEquals( + sign(algorithm, data, rsaPrivatePkcs1Pem), + Buffer.from(testCase.signature, "hex"), + ); + } + } + }, +}); diff --git a/tests/unit_node/crypto/ec_private_secp256r1.pem b/tests/unit_node/crypto/ec_private_secp256r1.pem new file mode 100644 index 000000000..f1d5c5769 --- /dev/null +++ b/tests/unit_node/crypto/ec_private_secp256r1.pem @@ -0,0 +1,5 @@ +-----BEGIN PRIVATE KEY----- +MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgbT/dwqGGyRs19qy8 +XPyAZVluvTE9N6hIbyVuFyZobrahRANCAATeWMJqmunAZ6o2lumC79MklBB3Z7ZF +ToryVl8HXevci1d/R+OZ6FjYnoICxw3rMXiKMDtUTAFi2ikL20O4+62M +-----END PRIVATE KEY----- diff --git a/tests/unit_node/crypto/gcmEncryptExtIV128.json b/tests/unit_node/crypto/gcmEncryptExtIV128.json new file mode 100644 index 000000000..64896642d --- /dev/null +++ b/tests/unit_node/crypto/gcmEncryptExtIV128.json @@ -0,0 +1,51377 @@ +[ + { + "key": [ + 17, + 117, + 76, + 215, + 42, + 236, + 48, + 155, + 245, + 47, + 118, + 135, + 33, + 46, + 137, + 87 + ], + "nonce": [ + 60, + 129, + 157, + 154, + 155, + 237, + 8, + 118, + 21, + 3, + 11, + 101 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 37, + 3, + 39, + 198, + 116, + 170, + 244, + 119, + 174, + 242, + 103, + 87, + 72, + 207, + 105, + 113 + ] + }, + { + "key": [ + 202, + 71, + 36, + 138, + 192, + 182, + 248, + 55, + 42, + 151, + 172, + 67, + 80, + 131, + 8, + 237 + ], + "nonce": [ + 255, + 210, + 181, + 152, + 254, + 171, + 201, + 1, + 146, + 98, + 210, + 190 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 96, + 210, + 4, + 4, + 175, + 82, + 125, + 36, + 141, + 137, + 58, + 228, + 149, + 112, + 125, + 26 + ] + }, + { + "key": [ + 219, + 26, + 208, + 189, + 28, + 246, + 219, + 11, + 93, + 134, + 239, + 221, + 137, + 20, + 178, + 24 + ], + "nonce": [ + 54, + 250, + 214, + 172, + 179, + 201, + 142, + 1, + 56, + 174, + 185, + 177 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 94, + 226, + 186, + 115, + 125, + 63, + 42, + 148, + 75, + 51, + 90, + 129, + 246, + 101, + 60, + 206 + ] + }, + { + "key": [ + 28, + 113, + 53, + 175, + 98, + 124, + 4, + 195, + 41, + 87, + 243, + 63, + 154, + 192, + 133, + 144 + ], + "nonce": [ + 53, + 92, + 9, + 79, + 160, + 156, + 142, + 146, + 129, + 23, + 141, + 52 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 182, + 171, + 44, + 125, + 144, + 108, + 157, + 158, + 196, + 193, + 73, + 141, + 44, + 187, + 80, + 41 + ] + }, + { + "key": [ + 108, + 162, + 193, + 18, + 5, + 166, + 229, + 90, + 181, + 4, + 219, + 243, + 73, + 31, + 139, + 220 + ], + "nonce": [ + 177, + 0, + 139, + 101, + 10, + 47, + 238, + 100, + 33, + 117, + 198, + 13 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 122, + 154, + 34, + 93, + 95, + 154, + 14, + 191, + 224, + 230, + 159, + 55, + 24, + 113, + 166, + 114 + ] + }, + { + "key": [ + 105, + 242, + 202, + 120, + 187, + 86, + 144, + 172, + 198, + 88, + 115, + 2, + 98, + 136, + 40, + 213 + ], + "nonce": [ + 112, + 29, + 162, + 130, + 203, + 107, + 96, + 24, + 218, + 189, + 0, + 211 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 171, + 29, + 64, + 221, + 161, + 121, + 141, + 86, + 104, + 120, + 146, + 226, + 21, + 157, + 236, + 253 + ] + }, + { + "key": [ + 220, + 244, + 227, + 57, + 196, + 135, + 182, + 121, + 122, + 172, + 169, + 49, + 114, + 95, + 123, + 189 + ], + "nonce": [ + 44, + 29, + 149, + 94, + 53, + 54, + 103, + 96, + 234, + 216, + 129, + 124 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 50, + 181, + 66, + 197, + 243, + 68, + 204, + 236, + 235, + 70, + 10, + 2, + 147, + 141, + 107, + 12 + ] + }, + { + "key": [ + 118, + 88, + 205, + 187, + 129, + 87, + 42, + 35, + 167, + 142, + 228, + 89, + 111, + 132, + 78, + 233 + ], + "nonce": [ + 28, + 59, + 170, + 233, + 185, + 6, + 89, + 97, + 132, + 44, + 190, + 82 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 112, + 199, + 18, + 63, + 200, + 25, + 170, + 6, + 14, + 210, + 211, + 193, + 89, + 182, + 234, + 65 + ] + }, + { + "key": [ + 40, + 26, + 87, + 11, + 30, + 143, + 38, + 94, + 224, + 147, + 3, + 236, + 174, + 12, + 196, + 109 + ], + "nonce": [ + 140, + 41, + 65, + 247, + 60, + 248, + 113, + 58, + 213, + 188, + 19, + 223 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 164, + 46, + 94, + 95, + 111, + 176, + 10, + 159, + 18, + 6, + 179, + 2, + 237, + 191, + 216, + 124 + ] + }, + { + "key": [ + 205, + 51, + 42, + 152, + 111, + 130, + 217, + 140, + 33, + 82, + 120, + 19, + 26, + 211, + 135, + 183 + ], + "nonce": [ + 29, + 18, + 178, + 89, + 244, + 75, + 135, + 61, + 57, + 66, + 188, + 17 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 52, + 35, + 128, + 35, + 100, + 129, + 133, + 215, + 239, + 12, + 252, + 245, + 131, + 110, + 147, + 204 + ] + }, + { + "key": [ + 128, + 225, + 217, + 141, + 16, + 178, + 114, + 55, + 56, + 111, + 2, + 145, + 137, + 236, + 4, + 72 + ], + "nonce": [ + 35, + 158, + 186, + 178, + 245, + 36, + 253, + 98, + 197, + 84, + 161, + 144 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 76, + 15, + 41, + 217, + 99, + 240, + 237, + 104, + 220, + 207, + 52, + 73, + 108, + 244, + 61, + 0 + ] + }, + { + "key": [ + 64, + 101, + 12, + 219, + 97, + 227, + 225, + 154, + 26, + 152, + 251, + 78, + 5, + 55, + 125, + 53 + ], + "nonce": [ + 105, + 240, + 168, + 26, + 175, + 107, + 184, + 72, + 98, + 130, + 241, + 185 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 38, + 87, + 225, + 45, + 236, + 33, + 195, + 236, + 240, + 113, + 175, + 97, + 121, + 82, + 159, + 180 + ] + }, + { + "key": [ + 30, + 137, + 166, + 205, + 117, + 40, + 204, + 225, + 226, + 178, + 181, + 247, + 253, + 43, + 107, + 82 + ], + "nonce": [ + 225, + 31, + 212, + 39, + 167, + 130, + 213, + 67, + 247, + 142, + 252, + 96 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 238, + 237, + 255, + 135, + 76, + 142, + 222, + 234, + 83, + 232, + 190, + 42, + 19, + 175, + 216, + 27 + ] + }, + { + "key": [ + 42, + 122, + 214, + 20, + 102, + 118, + 5, + 125, + 183, + 119, + 222, + 164, + 104, + 61, + 13, + 69 + ], + "nonce": [ + 237, + 114, + 30, + 166, + 116, + 86, + 212, + 89, + 74, + 175, + 189, + 81 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 238, + 60, + 171, + 87, + 120, + 136, + 132, + 57, + 217, + 15, + 167, + 24, + 183, + 87, + 56, + 173 + ] + }, + { + "key": [ + 163, + 100, + 244, + 148, + 164, + 205, + 1, + 71, + 195, + 71, + 49, + 7, + 77, + 193, + 168, + 91 + ], + "nonce": [ + 74, + 168, + 71, + 13, + 212, + 4, + 228, + 5, + 75, + 48, + 9, + 58 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 216, + 167, + 187, + 163, + 164, + 81, + 144, + 46, + 58, + 220, + 1, + 6, + 12, + 60, + 145, + 167 + ] + }, + { + "key": [ + 119, + 190, + 99, + 112, + 137, + 113, + 196, + 226, + 64, + 209, + 203, + 121, + 232, + 215, + 127, + 235 + ], + "nonce": [ + 224, + 224, + 15, + 25, + 254, + 215, + 186, + 1, + 54, + 167, + 151, + 243 + ], + "aad": [ + 122, + 67, + 236, + 29, + 156, + 10, + 90, + 120, + 160, + 177, + 101, + 51, + 166, + 33, + 60, + 171 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 32, + 159, + 204, + 141, + 54, + 117, + 237, + 147, + 142, + 156, + 113, + 102, + 112, + 157, + 217, + 70 + ] + }, + { + "key": [ + 118, + 128, + 197, + 211, + 202, + 97, + 84, + 117, + 142, + 81, + 15, + 77, + 37, + 185, + 136, + 32 + ], + "nonce": [ + 248, + 241, + 5, + 249, + 195, + 223, + 73, + 101, + 120, + 3, + 33, + 248 + ], + "aad": [ + 201, + 76, + 65, + 1, + 148, + 199, + 101, + 227, + 220, + 199, + 150, + 67, + 121, + 117, + 142, + 211 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 148, + 220, + 168, + 237, + 252, + 249, + 11, + 183, + 75, + 21, + 60, + 141, + 72, + 161, + 121, + 48 + ] + }, + { + "key": [ + 168, + 43, + 177, + 237, + 199, + 192, + 26, + 54, + 137, + 0, + 111, + 52, + 191, + 237, + 120, + 62 + ], + "nonce": [ + 150, + 56, + 54, + 182, + 123, + 24, + 139, + 236, + 249, + 186, + 20, + 17 + ], + "aad": [ + 157, + 17, + 91, + 185, + 187, + 209, + 25, + 251, + 119, + 123, + 99, + 22, + 6, + 90, + 154, + 200 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 196, + 145, + 136, + 159, + 163, + 236, + 164, + 84, + 75, + 160, + 213, + 27, + 142, + 15, + 56, + 55 + ] + }, + { + "key": [ + 185, + 120, + 45, + 10, + 89, + 134, + 198, + 63, + 53, + 45, + 59, + 196, + 199, + 236, + 201, + 109 + ], + "nonce": [ + 69, + 65, + 225, + 91, + 146, + 237, + 234, + 68, + 236, + 235, + 31, + 42 + ], + "aad": [ + 241, + 169, + 240, + 114, + 52, + 41, + 197, + 178, + 97, + 133, + 172, + 62, + 167, + 225, + 61, + 122 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 116, + 208, + 211, + 105, + 73, + 240, + 39, + 102, + 112, + 249, + 221, + 197, + 121, + 233, + 79, + 58 + ] + }, + { + "key": [ + 89, + 185, + 87, + 133, + 179, + 15, + 32, + 86, + 121, + 252, + 79, + 63, + 154, + 144, + 16, + 47 + ], + "nonce": [ + 25, + 8, + 120, + 124, + 193, + 225, + 136, + 10, + 110, + 245, + 221, + 23 + ], + "aad": [ + 57, + 133, + 45, + 49, + 130, + 148, + 74, + 81, + 119, + 219, + 39, + 123, + 99, + 145, + 7, + 2 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 143, + 154, + 150, + 192, + 19, + 153, + 36, + 133, + 180, + 62, + 43, + 98, + 116, + 90, + 209, + 115 + ] + }, + { + "key": [ + 52, + 221, + 121, + 38, + 171, + 19, + 212, + 7, + 129, + 96, + 216, + 125, + 226, + 227, + 199, + 36 + ], + "nonce": [ + 193, + 28, + 205, + 175, + 121, + 138, + 176, + 58, + 242, + 217, + 126, + 249 + ], + "aad": [ + 175, + 105, + 135, + 23, + 166, + 215, + 144, + 179, + 191, + 195, + 145, + 149, + 133, + 123, + 181, + 255 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 72, + 17, + 96, + 80, + 187, + 217, + 17, + 130, + 112, + 208, + 190, + 37, + 45, + 41, + 213, + 212 + ] + }, + { + "key": [ + 142, + 200, + 111, + 171, + 85, + 170, + 171, + 14, + 119, + 69, + 94, + 156, + 211, + 219, + 199, + 142 + ], + "nonce": [ + 21, + 253, + 144, + 169, + 134, + 126, + 20, + 240, + 214, + 59, + 83, + 185 + ], + "aad": [ + 231, + 80, + 158, + 39, + 98, + 9, + 166, + 211, + 236, + 250, + 187, + 83, + 204, + 220, + 210, + 54 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 217, + 109, + 106, + 192, + 211, + 9, + 206, + 190, + 222, + 186, + 42, + 249, + 242, + 98, + 19, + 47 + ] + }, + { + "key": [ + 102, + 178, + 71, + 61, + 158, + 1, + 33, + 102, + 109, + 71, + 99, + 63, + 112, + 8, + 235, + 28 + ], + "nonce": [ + 193, + 113, + 108, + 104, + 162, + 77, + 87, + 119, + 11, + 134, + 126, + 81 + ], + "aad": [ + 194, + 15, + 104, + 99, + 23, + 214, + 126, + 83, + 221, + 121, + 186, + 229, + 196, + 109, + 193, + 17 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 154, + 8, + 97, + 104, + 9, + 207, + 21, + 36, + 125, + 254, + 185, + 117, + 107, + 164, + 246, + 9 + ] + }, + { + "key": [ + 91, + 38, + 42, + 157, + 0, + 144, + 77, + 48, + 162, + 88, + 124, + 170, + 222, + 9, + 19, + 129 + ], + "nonce": [ + 247, + 188, + 21, + 76, + 165, + 98, + 232, + 242, + 193, + 132, + 85, + 152 + ], + "aad": [ + 35, + 17, + 45, + 7, + 140, + 153, + 20, + 250, + 61, + 254, + 82, + 24, + 205, + 25, + 16, + 22 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 152, + 133, + 77, + 25, + 58, + 6, + 219, + 227, + 44, + 228, + 73, + 126, + 236, + 92, + 154, + 139 + ] + }, + { + "key": [ + 46, + 79, + 185, + 204, + 50, + 1, + 136, + 166, + 241, + 250, + 137, + 167, + 162, + 82, + 39, + 58 + ], + "nonce": [ + 122, + 109, + 78, + 230, + 156, + 114, + 86, + 193, + 79, + 186, + 143, + 94 + ], + "aad": [ + 128, + 186, + 74, + 32, + 42, + 104, + 195, + 89, + 13, + 101, + 87, + 145, + 44, + 111, + 135, + 142 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 146, + 128, + 49, + 50, + 115, + 190, + 251, + 138, + 250, + 11, + 206, + 202, + 90, + 150, + 109, + 133 + ] + }, + { + "key": [ + 94, + 169, + 73, + 115, + 216, + 97, + 109, + 175, + 167, + 243, + 29, + 176, + 113, + 109, + 23, + 41 + ], + "nonce": [ + 160, + 91, + 98, + 102, + 157, + 37, + 14, + 97, + 176, + 119, + 210, + 138 + ], + "aad": [ + 150, + 32, + 186, + 242, + 245, + 141, + 1, + 63, + 138, + 76, + 72, + 113, + 152, + 156, + 27, + 23 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 126, + 85, + 3, + 152, + 222, + 231, + 40, + 37, + 109, + 105, + 40, + 205, + 170, + 196, + 59, + 115 + ] + }, + { + "key": [ + 145, + 3, + 133, + 246, + 240, + 127, + 158, + 87, + 228, + 131, + 196, + 125, + 213, + 32, + 107, + 204 + ], + "nonce": [ + 81, + 143, + 86, + 227, + 54, + 88, + 223, + 49, + 29, + 66, + 217, + 254 + ], + "aad": [ + 93, + 21, + 121, + 9, + 162, + 164, + 96, + 113, + 23, + 231, + 125, + 160, + 228, + 73, + 59, + 136 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 167, + 4, + 30, + 164, + 161, + 215, + 77, + 158, + 102, + 185, + 87, + 27, + 89, + 182, + 161, + 216 + ] + }, + { + "key": [ + 202, + 179, + 175, + 122, + 21, + 180, + 48, + 224, + 52, + 231, + 147, + 187, + 48, + 219, + 138, + 178 + ], + "nonce": [ + 150, + 58, + 86, + 226, + 225, + 47, + 56, + 112, + 98, + 225, + 132, + 152 + ], + "aad": [ + 160, + 148, + 161, + 221, + 17, + 33, + 211, + 170, + 82, + 200, + 30, + 143, + 16, + 191, + 159, + 12 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 26, + 49, + 210, + 149, + 96, + 30, + 179, + 200, + 42, + 84, + 178, + 52, + 152, + 79, + 253, + 245 + ] + }, + { + "key": [ + 137, + 201, + 73, + 233, + 200, + 4, + 175, + 1, + 77, + 86, + 4, + 179, + 148, + 89, + 242, + 200 + ], + "nonce": [ + 209, + 177, + 4, + 200, + 21, + 191, + 30, + 148, + 226, + 140, + 143, + 22 + ], + "aad": [ + 130, + 173, + 205, + 99, + 141, + 63, + 169, + 217, + 243, + 232, + 65, + 0, + 214, + 30, + 7, + 119 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 136, + 219, + 157, + 98, + 23, + 46, + 208, + 67, + 170, + 16, + 241, + 109, + 34, + 125, + 196, + 27 + ] + }, + { + "key": [ + 164, + 217, + 148, + 196, + 172, + 90, + 192, + 240, + 41, + 19, + 36, + 87, + 20, + 251, + 226, + 53 + ], + "nonce": [ + 169, + 71, + 45, + 173, + 204, + 168, + 215, + 224, + 227, + 184, + 8, + 77 + ], + "aad": [ + 235, + 49, + 139, + 158, + 23, + 87, + 82, + 3, + 221, + 41, + 235, + 237, + 32, + 236, + 130, + 249 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 50, + 61, + 247, + 243, + 54, + 148, + 16, + 111, + 86, + 115, + 157, + 224, + 151, + 50, + 22, + 163 + ] + }, + { + "key": [ + 47, + 180, + 94, + 91, + 143, + 153, + 58, + 43, + 254, + 188, + 75, + 21, + 181, + 51, + 224, + 180 + ], + "nonce": [ + 91, + 5, + 117, + 95, + 152, + 77, + 43, + 144, + 249, + 75, + 128, + 39 + ], + "aad": [ + 232, + 84, + 145, + 178, + 32, + 44, + 175, + 29, + 125, + 206, + 3, + 185, + 126, + 9, + 51, + 28, + 50, + 71, + 57, + 65 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 199, + 91, + 120, + 50, + 178, + 162, + 217, + 189, + 130, + 116, + 18, + 182, + 239, + 87, + 105, + 219 + ] + }, + { + "key": [ + 149, + 33, + 23, + 4, + 143, + 119, + 226, + 118, + 194, + 239, + 101, + 128, + 83, + 124, + 20, + 3 + ], + "nonce": [ + 7, + 11, + 143, + 180, + 106, + 122, + 213, + 40, + 133, + 190, + 27, + 38 + ], + "aad": [ + 52, + 176, + 136, + 249, + 130, + 129, + 139, + 95, + 7, + 218, + 190, + 43, + 98, + 249, + 84, + 127, + 78, + 208, + 153, + 18 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 190, + 221, + 76, + 243, + 15, + 215, + 164, + 171, + 196, + 155, + 220, + 195, + 243, + 178, + 72, + 177 + ] + }, + { + "key": [ + 127, + 100, + 83, + 179, + 155, + 222, + 1, + 133, + 96, + 161, + 106, + 39, + 4, + 33, + 117, + 67 + ], + "nonce": [ + 15, + 62, + 236, + 244, + 141, + 104, + 53, + 50, + 38, + 167, + 127, + 228 + ], + "aad": [ + 17, + 228, + 236, + 178, + 86, + 235, + 255, + 86, + 69, + 63, + 162, + 231, + 94, + 67, + 235, + 157, + 100, + 16, + 73, + 230 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 181, + 18, + 98, + 58, + 18, + 213, + 73, + 43, + 125, + 118, + 211, + 155, + 224, + 223, + 87, + 119 + ] + }, + { + "key": [ + 147, + 50, + 228, + 51, + 191, + 97, + 0, + 198, + 204, + 35, + 176, + 135, + 16, + 98, + 124, + 64 + ], + "nonce": [ + 170, + 179, + 219, + 48, + 21, + 178, + 157, + 36, + 243, + 41, + 190, + 180 + ], + "aad": [ + 189, + 132, + 58, + 8, + 240, + 168, + 34, + 248, + 244, + 247, + 108, + 54, + 72, + 56, + 10, + 171, + 118, + 34, + 231, + 25 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 229, + 79, + 29, + 24, + 198, + 29, + 139, + 225, + 84, + 132, + 114, + 118, + 5, + 181, + 165, + 220 + ] + }, + { + "key": [ + 87, + 115, + 117, + 10, + 73, + 48, + 150, + 169, + 157, + 132, + 192, + 86, + 63, + 194, + 147, + 233 + ], + "nonce": [ + 195, + 144, + 237, + 112, + 220, + 148, + 151, + 35, + 68, + 19, + 173, + 82 + ], + "aad": [ + 96, + 18, + 81, + 114, + 88, + 113, + 108, + 31, + 0, + 53, + 239, + 166, + 10, + 15, + 54, + 181, + 198, + 94, + 115, + 121 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 176, + 17, + 178, + 100, + 97, + 14, + 88, + 8, + 39, + 5, + 71, + 111, + 4, + 11, + 140, + 134 + ] + }, + { + "key": [ + 65, + 176, + 208, + 252, + 229, + 211, + 19, + 89, + 207, + 213, + 219, + 64, + 100, + 226, + 212, + 107 + ], + "nonce": [ + 185, + 3, + 233, + 208, + 206, + 162, + 87, + 149, + 168, + 46, + 115, + 227 + ], + "aad": [ + 76, + 186, + 80, + 24, + 118, + 243, + 62, + 31, + 218, + 156, + 212, + 86, + 227, + 24, + 6, + 131, + 227, + 134, + 59, + 217 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 24, + 188, + 57, + 208, + 185, + 92, + 240, + 89, + 205, + 140, + 37, + 0, + 79, + 94, + 80, + 124 + ] + }, + { + "key": [ + 71, + 72, + 183, + 130, + 227, + 254, + 94, + 78, + 255, + 235, + 124, + 103, + 35, + 45, + 43, + 7 + ], + "nonce": [ + 197, + 228, + 220, + 241, + 143, + 134, + 7, + 107, + 136, + 165, + 213, + 233 + ], + "aad": [ + 59, + 47, + 202, + 216, + 115, + 158, + 216, + 126, + 29, + 2, + 232, + 8, + 69, + 241, + 32, + 226, + 73, + 234, + 146, + 177 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 184, + 174, + 113, + 142, + 40, + 121, + 201, + 203, + 101, + 141, + 93, + 17, + 34, + 230, + 155, + 183 + ] + }, + { + "key": [ + 227, + 12, + 194, + 32, + 119, + 213, + 149, + 18, + 22, + 208, + 127, + 55, + 197, + 27, + 88, + 249 + ], + "nonce": [ + 252, + 88, + 58, + 209, + 89, + 181, + 46, + 11, + 99, + 120, + 21, + 126 + ], + "aad": [ + 195, + 203, + 123, + 232, + 136, + 142, + 244, + 76, + 165, + 170, + 147, + 221, + 226, + 109, + 39, + 81, + 40, + 142, + 31, + 90 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 168, + 206, + 37, + 181, + 220, + 143, + 132, + 226, + 245, + 218, + 229, + 240, + 133, + 170, + 204, + 212 + ] + }, + { + "key": [ + 124, + 139, + 16, + 186, + 117, + 238, + 106, + 180, + 169, + 151, + 211, + 245, + 152, + 183, + 157, + 64 + ], + "nonce": [ + 111, + 181, + 81, + 136, + 221, + 240, + 13, + 222, + 9, + 89, + 101, + 135 + ], + "aad": [ + 45, + 220, + 10, + 207, + 151, + 5, + 248, + 209, + 143, + 144, + 91, + 143, + 157, + 71, + 46, + 125, + 191, + 107, + 145, + 227 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 87, + 145, + 211, + 128, + 81, + 9, + 197, + 225, + 138, + 223, + 244, + 232, + 9, + 6, + 160, + 24 + ] + }, + { + "key": [ + 114, + 199, + 219, + 108, + 162, + 159, + 131, + 100, + 28, + 63, + 255, + 91, + 113, + 196, + 188, + 48 + ], + "nonce": [ + 242, + 0, + 7, + 66, + 226, + 73, + 172, + 86, + 213, + 178, + 246, + 95 + ], + "aad": [ + 205, + 153, + 77, + 45, + 8, + 35, + 39, + 112, + 146, + 125, + 133, + 78, + 242, + 182, + 202, + 47, + 8, + 115, + 112, + 207 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 165, + 150, + 109, + 243, + 159, + 238, + 186, + 3, + 54, + 240, + 185, + 163, + 244, + 255, + 230, + 195 + ] + }, + { + "key": [ + 40, + 51, + 204, + 16, + 25, + 80, + 48, + 228, + 161, + 21, + 85, + 50, + 102, + 108, + 176, + 73 + ], + "nonce": [ + 173, + 128, + 43, + 154, + 92, + 148, + 9, + 250, + 62, + 125, + 207, + 204 + ], + "aad": [ + 179, + 236, + 190, + 162, + 121, + 125, + 0, + 108, + 7, + 184, + 206, + 98, + 27, + 227, + 176, + 236, + 205, + 55, + 195, + 236 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 129, + 222, + 171, + 139, + 222, + 224, + 211, + 145, + 73, + 94, + 237, + 64, + 41, + 166, + 210, + 5 + ] + }, + { + "key": [ + 216, + 152, + 91, + 181, + 172, + 2, + 88, + 173, + 173, + 134, + 102, + 14, + 187, + 198, + 209, + 159 + ], + "nonce": [ + 181, + 238, + 38, + 248, + 196, + 99, + 187, + 252, + 39, + 17, + 91, + 10 + ], + "aad": [ + 97, + 63, + 81, + 248, + 50, + 251, + 244, + 52, + 184, + 227, + 254, + 148, + 84, + 174, + 70, + 168, + 98, + 216, + 49, + 240 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 254, + 159, + 11, + 27, + 220, + 104, + 222, + 230, + 232, + 220, + 44, + 225, + 38, + 101, + 211, + 54 + ] + }, + { + "key": [ + 155, + 143, + 105, + 36, + 220, + 34, + 241, + 7, + 60, + 26, + 56, + 68, + 138, + 47, + 4, + 71 + ], + "nonce": [ + 9, + 205, + 171, + 248, + 125, + 130, + 130, + 142, + 202, + 28, + 12, + 127 + ], + "aad": [ + 105, + 33, + 14, + 78, + 10, + 28, + 253, + 80, + 56, + 117, + 102, + 82, + 121, + 11, + 154, + 140, + 251, + 189, + 148, + 61 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 166, + 12, + 16, + 74, + 111, + 180, + 99, + 132, + 39, + 168, + 138, + 134, + 192, + 73, + 35, + 189 + ] + }, + { + "key": [ + 114, + 19, + 34, + 19, + 213, + 217, + 83, + 9, + 191, + 126, + 16, + 248, + 49, + 141, + 124, + 32 + ], + "nonce": [ + 251, + 144, + 191, + 40, + 60, + 84, + 17, + 35, + 3, + 85, + 215, + 161 + ], + "aad": [ + 163, + 11, + 177, + 124, + 128, + 137, + 198, + 245, + 246, + 27, + 37, + 10, + 148, + 203, + 187, + 253, + 245, + 242, + 163, + 230 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 9, + 25, + 26, + 244, + 24, + 148, + 159, + 230, + 190, + 141, + 191, + 19, + 224, + 6, + 82, + 122 + ] + }, + { + "key": [ + 101, + 47, + 251, + 173, + 78, + 31, + 203, + 231, + 85, + 100, + 57, + 94, + 108, + 28, + 57, + 36 + ], + "nonce": [ + 17, + 19, + 73, + 99, + 109, + 16, + 111, + 213, + 246, + 161, + 224, + 136 + ], + "aad": [ + 95, + 82, + 170, + 133, + 220, + 58, + 192, + 66, + 100, + 126, + 50, + 173, + 160, + 80, + 214, + 126, + 89, + 181, + 25, + 170 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 40, + 217, + 128, + 215, + 191, + 216, + 120, + 194, + 39, + 193, + 64, + 222, + 52, + 130, + 118, + 91 + ] + }, + { + "key": [ + 153, + 227, + 232, + 121, + 62, + 104, + 110, + 87, + 29, + 130, + 133, + 197, + 100, + 247, + 94, + 43 + ], + "nonce": [ + 194, + 221, + 10, + 184, + 104, + 218, + 106, + 168, + 173, + 156, + 13, + 35 + ], + "aad": [ + 182, + 104, + 228, + 45, + 78, + 68, + 76, + 168, + 178, + 60, + 253, + 217, + 90, + 159, + 237, + 213, + 23, + 138, + 165, + 33, + 20, + 72, + 144, + 176, + 147, + 115, + 60, + 245, + 207, + 34, + 82, + 108, + 89, + 23, + 238, + 71, + 101, + 65, + 128, + 154, + 198, + 134, + 122, + 140, + 57, + 147, + 9, + 252 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 63, + 79, + 186, + 16, + 14, + 175, + 31, + 52, + 176, + 186, + 173, + 170, + 233, + 153, + 93, + 133 + ] + }, + { + "key": [ + 248, + 226, + 158, + 253, + 0, + 164, + 35, + 196, + 234, + 148, + 86, + 134, + 63, + 131, + 197, + 79 + ], + "nonce": [ + 45, + 60, + 246, + 124, + 188, + 230, + 157, + 99, + 155, + 209, + 192, + 146 + ], + "aad": [ + 2, + 199, + 15, + 200, + 162, + 84, + 70, + 25, + 193, + 195, + 233, + 252, + 230, + 179, + 198, + 195, + 188, + 36, + 100, + 62, + 15, + 20, + 14, + 107, + 72, + 172, + 80, + 94, + 166, + 102, + 205, + 154, + 32, + 16, + 195, + 168, + 226, + 245, + 241, + 4, + 55, + 136, + 127, + 232, + 3, + 181, + 77, + 179 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 150, + 60, + 181, + 10, + 202, + 62, + 9, + 221, + 13, + 154, + 1, + 60, + 135, + 52, + 21, + 95 + ] + }, + { + "key": [ + 0, + 227, + 73, + 29, + 252, + 243, + 190, + 195, + 156, + 137, + 204, + 253, + 128, + 165, + 168, + 150 + ], + "nonce": [ + 41, + 246, + 255, + 78, + 220, + 74, + 195, + 233, + 127, + 251, + 22, + 128 + ], + "aad": [ + 115, + 129, + 51, + 81, + 179, + 159, + 94, + 64, + 0, + 169, + 238, + 141, + 43, + 133, + 241, + 49, + 99, + 74, + 202, + 237, + 224, + 221, + 37, + 214, + 145, + 162, + 184, + 41, + 173, + 79, + 233, + 234, + 105, + 159, + 18, + 36, + 37, + 25, + 132, + 124, + 176, + 131, + 176, + 180, + 211, + 216, + 179, + 188 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 1, + 178, + 233, + 186, + 113, + 154, + 215, + 124, + 117, + 59, + 54, + 78, + 204, + 90, + 171, + 235 + ] + }, + { + "key": [ + 10, + 208, + 111, + 76, + 25, + 175, + 29, + 95, + 96, + 43, + 56, + 248, + 110, + 86, + 41, + 28 + ], + "nonce": [ + 11, + 35, + 92, + 106, + 117, + 206, + 205, + 252, + 186, + 144, + 1, + 206 + ], + "aad": [ + 125, + 79, + 38, + 247, + 137, + 91, + 46, + 243, + 218, + 46, + 79, + 147, + 228, + 17, + 205, + 183, + 64, + 37, + 199, + 117, + 156, + 3, + 141, + 135, + 35, + 68, + 164, + 92, + 229, + 109, + 146, + 165, + 129, + 134, + 44, + 59, + 172, + 224, + 57, + 9, + 10, + 44, + 207, + 164, + 59, + 98, + 61, + 203 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 180, + 188, + 156, + 225, + 71, + 93, + 12, + 147, + 223, + 213, + 165, + 216, + 212, + 91, + 216, + 229 + ] + }, + { + "key": [ + 238, + 235, + 51, + 224, + 200, + 164, + 6, + 234, + 35, + 106, + 7, + 92, + 219, + 233, + 214, + 249 + ], + "nonce": [ + 185, + 53, + 232, + 238, + 214, + 98, + 39, + 131, + 110, + 222, + 24, + 154 + ], + "aad": [ + 154, + 66, + 145, + 172, + 185, + 146, + 75, + 186, + 66, + 65, + 176, + 201, + 195, + 194, + 225, + 38, + 43, + 37, + 167, + 199, + 240, + 44, + 146, + 173, + 234, + 223, + 146, + 37, + 77, + 97, + 138, + 181, + 147, + 136, + 170, + 48, + 180, + 126, + 175, + 165, + 136, + 153, + 195, + 87, + 207, + 40, + 30, + 49 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 20, + 61, + 105, + 84, + 235, + 111, + 231, + 10, + 255, + 112, + 218, + 151, + 140, + 205, + 69, + 9 + ] + }, + { + "key": [ + 96, + 11, + 84, + 66, + 160, + 181, + 80, + 163, + 143, + 133, + 210, + 251, + 10, + 204, + 156, + 150 + ], + "nonce": [ + 94, + 101, + 221, + 110, + 139, + 32, + 214, + 178, + 147, + 31, + 230, + 194 + ], + "aad": [ + 70, + 30, + 84, + 160, + 146, + 248, + 57, + 36, + 102, + 132, + 159, + 176, + 55, + 10, + 227, + 12, + 20, + 193, + 191, + 57, + 135, + 171, + 46, + 187, + 233, + 142, + 24, + 209, + 63, + 4, + 29, + 9, + 208, + 67, + 247, + 174, + 167, + 139, + 252, + 196, + 47, + 134, + 74, + 159, + 180, + 15, + 0, + 49 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 44, + 214, + 38, + 249, + 160, + 104, + 99, + 0, + 207, + 35, + 192, + 188, + 89, + 124, + 99, + 180 + ] + }, + { + "key": [ + 206, + 141, + 17, + 3, + 16, + 15, + 162, + 144, + 249, + 83, + 251, + 180, + 57, + 239, + 222, + 228 + ], + "nonce": [ + 72, + 116, + 198, + 248, + 8, + 35, + 102, + 252, + 126, + 73, + 185, + 51 + ], + "aad": [ + 214, + 157, + 3, + 60, + 50, + 2, + 151, + 137, + 38, + 60, + 104, + 158, + 17, + 255, + 126, + 158, + 142, + 239, + 196, + 141, + 219, + 196, + 225, + 14, + 234, + 225, + 201, + 237, + 187, + 68, + 240, + 78, + 124, + 198, + 71, + 21, + 1, + 234, + 221, + 163, + 148, + 10, + 180, + 51, + 208, + 168, + 194, + 16 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 165, + 150, + 75, + 119, + 175, + 11, + 138, + 236, + 216, + 68, + 214, + 173, + 236, + 139, + 123, + 28 + ] + }, + { + "key": [ + 174, + 113, + 20, + 192, + 159, + 250, + 4, + 41, + 136, + 52, + 65, + 47, + 106, + 141, + 228, + 83 + ], + "nonce": [ + 243, + 128, + 194, + 216, + 96, + 190, + 42, + 244, + 30, + 27, + 229, + 198 + ], + "aad": [ + 126, + 22, + 8, + 47, + 104, + 156, + 99, + 232, + 173, + 221, + 213, + 203, + 45, + 166, + 16, + 187, + 251, + 136, + 208, + 115, + 207, + 139, + 32, + 67, + 132, + 169, + 55, + 170, + 176, + 55, + 101, + 35, + 165, + 13, + 61, + 95, + 19, + 146, + 151, + 143, + 121, + 96, + 159, + 18, + 223, + 143, + 194, + 136 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 64, + 211, + 163, + 99, + 88, + 166, + 246, + 202, + 170, + 106, + 249, + 44, + 253, + 135, + 74, + 34 + ] + }, + { + "key": [ + 216, + 245, + 32, + 182, + 243, + 207, + 107, + 131, + 92, + 228, + 204, + 228, + 143, + 76, + 176, + 51 + ], + "nonce": [ + 1, + 154, + 85, + 201, + 134, + 21, + 192, + 34, + 175, + 255, + 150, + 68 + ], + "aad": [ + 195, + 251, + 81, + 141, + 219, + 45, + 115, + 65, + 126, + 36, + 51, + 89, + 160, + 237, + 140, + 18, + 103, + 80, + 235, + 22, + 62, + 123, + 216, + 69, + 99, + 113, + 89, + 57, + 112, + 117, + 227, + 219, + 29, + 183, + 47, + 226, + 240, + 225, + 59, + 89, + 156, + 51, + 60, + 71, + 63, + 235, + 34, + 69 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 70, + 124, + 250, + 213, + 175, + 17, + 133, + 45, + 110, + 202, + 40, + 156, + 134, + 249, + 103, + 173 + ] + }, + { + "key": [ + 19, + 186, + 149, + 96, + 107, + 1, + 175, + 3, + 91, + 249, + 97, + 227, + 152, + 82, + 227, + 75 + ], + "nonce": [ + 158, + 201, + 207, + 59, + 0, + 44, + 254, + 217, + 231, + 97, + 147, + 79 + ], + "aad": [ + 187, + 157, + 229, + 99, + 131, + 109, + 31, + 27, + 29, + 233, + 100, + 81, + 78, + 206, + 187, + 138, + 209, + 5, + 1, + 219, + 86, + 34, + 128, + 183, + 189, + 152, + 128, + 72, + 20, + 115, + 88, + 23, + 144, + 139, + 40, + 86, + 202, + 250, + 222, + 205, + 64, + 176, + 72, + 50, + 251, + 222, + 43, + 251 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 23, + 42, + 59, + 203, + 197, + 0, + 29, + 253, + 56, + 21, + 23, + 90, + 136, + 247, + 5, + 108 + ] + }, + { + "key": [ + 28, + 151, + 218, + 95, + 197, + 169, + 100, + 15, + 40, + 150, + 34, + 132, + 36, + 8, + 203, + 162 + ], + "nonce": [ + 109, + 118, + 90, + 152, + 142, + 147, + 69, + 136, + 22, + 62, + 41, + 183 + ], + "aad": [ + 16, + 38, + 165, + 144, + 129, + 109, + 46, + 26, + 166, + 122, + 160, + 209, + 61, + 80, + 168, + 65, + 58, + 244, + 216, + 238, + 155, + 31, + 165, + 206, + 184, + 222, + 172, + 201, + 244, + 30, + 142, + 118, + 75, + 58, + 193, + 95, + 152, + 41, + 94, + 136, + 0, + 173, + 246, + 167, + 23, + 84, + 72, + 205 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 73, + 69, + 167, + 157, + 94, + 219, + 185, + 52, + 197, + 207, + 148, + 57, + 92, + 53, + 157, + 235 + ] + }, + { + "key": [ + 141, + 212, + 111, + 39, + 26, + 32, + 28, + 194, + 28, + 160, + 130, + 50, + 72, + 21, + 126, + 107 + ], + "nonce": [ + 24, + 33, + 179, + 16, + 206, + 45, + 186, + 153, + 156, + 223, + 117, + 118 + ], + "aad": [ + 52, + 186, + 64, + 153, + 151, + 206, + 186, + 6, + 95, + 74, + 84, + 87, + 7, + 138, + 158, + 35, + 42, + 132, + 245, + 148, + 1, + 26, + 236, + 253, + 191, + 189, + 36, + 168, + 2, + 202, + 18, + 158, + 1, + 203, + 19, + 39, + 226, + 101, + 180, + 169, + 0, + 79, + 180, + 197, + 0, + 63, + 255, + 211 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 48, + 76, + 194, + 205, + 47, + 205, + 212, + 171, + 200, + 68, + 188, + 156, + 28, + 190, + 2, + 65 + ] + }, + { + "key": [ + 12, + 84, + 93, + 149, + 51, + 59, + 106, + 207, + 139, + 41, + 40, + 243, + 239, + 208, + 131, + 222 + ], + "nonce": [ + 49, + 222, + 137, + 208, + 126, + 117, + 119, + 149, + 111, + 169, + 94, + 243 + ], + "aad": [ + 85, + 116, + 214, + 95, + 90, + 255, + 251, + 45, + 49, + 204, + 168, + 245, + 140, + 245, + 148, + 91, + 131, + 85, + 60, + 212, + 93, + 45, + 186, + 14, + 5, + 250, + 84, + 228, + 42, + 163, + 245, + 160, + 81, + 225, + 98, + 77, + 225, + 109, + 75, + 147, + 203, + 171, + 121, + 136, + 198, + 217, + 95, + 140 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 78, + 217, + 28, + 254, + 144, + 164, + 153, + 0, + 224, + 86, + 86, + 151, + 188, + 130, + 182, + 89 + ] + }, + { + "key": [ + 121, + 11, + 57, + 243, + 1, + 56, + 58, + 130, + 179, + 119, + 245, + 133, + 211, + 191, + 15, + 38 + ], + "nonce": [ + 47, + 217, + 193, + 66, + 181, + 252, + 98, + 232, + 126, + 255, + 241, + 253 + ], + "aad": [ + 69, + 99, + 78, + 10, + 252, + 89, + 174, + 159, + 110, + 48, + 247, + 245, + 254, + 67, + 207, + 90, + 78, + 31, + 120, + 208, + 174, + 187, + 158, + 90, + 122, + 217, + 216, + 111, + 37, + 39, + 142, + 82, + 31, + 72, + 69, + 212, + 157, + 108, + 181, + 51, + 202, + 198, + 67, + 152, + 57, + 100, + 127, + 208 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 105, + 99, + 124, + 63, + 146, + 51, + 218, + 35, + 248, + 223, + 123, + 9, + 232, + 207, + 178, + 82 + ] + }, + { + "key": [ + 143, + 99, + 101, + 38, + 50, + 208, + 123, + 42, + 74, + 131, + 194, + 109, + 237, + 211, + 38, + 87 + ], + "nonce": [ + 116, + 123, + 238, + 14, + 29, + 70, + 42, + 144, + 22, + 241, + 70, + 141 + ], + "aad": [ + 156, + 0, + 255, + 150, + 155, + 85, + 164, + 151, + 220, + 82, + 63, + 160, + 206, + 218, + 163, + 57, + 220, + 60, + 108, + 225, + 142, + 97, + 199, + 191, + 128, + 12, + 54, + 18, + 1, + 53, + 27, + 196, + 151, + 40, + 195, + 187, + 21, + 6, + 126, + 144, + 97, + 98, + 238, + 121, + 27, + 141, + 51, + 58 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 189, + 90, + 12, + 191, + 133, + 154, + 97, + 51, + 167, + 242, + 213, + 4, + 217, + 124, + 174, + 5 + ] + }, + { + "key": [ + 32, + 181, + 182, + 184, + 84, + 225, + 135, + 176, + 88, + 168, + 77, + 87, + 188, + 21, + 56, + 182 + ], + "nonce": [ + 148, + 193, + 147, + 90, + 252, + 6, + 28, + 191, + 37, + 75, + 147, + 111 + ], + "aad": [ + 202, + 65, + 142, + 113, + 219, + 248, + 16, + 3, + 129, + 116, + 234, + 163, + 113, + 155, + 63, + 203, + 128, + 83, + 28, + 113, + 16, + 173, + 145, + 146, + 209, + 5, + 238, + 170, + 250, + 21, + 184, + 25, + 172, + 0, + 86, + 104, + 117, + 43, + 52, + 78, + 209, + 178, + 47, + 175, + 119, + 4, + 139, + 175, + 3, + 219, + 221, + 179, + 180, + 125, + 107, + 0, + 233, + 92, + 79, + 0, + 94, + 12, + 201, + 183, + 98, + 124, + 202, + 253, + 63, + 33, + 179, + 49, + 42, + 168, + 217, + 29, + 63, + 160, + 137, + 63, + 229, + 191, + 247, + 212, + 76, + 164, + 111, + 35, + 175, + 224 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 179, + 114, + 134, + 235, + 175, + 74, + 84, + 224, + 255, + 194, + 161, + 222, + 175, + 201, + 246, + 219 + ] + }, + { + "key": [ + 122, + 165, + 49, + 136, + 169, + 197, + 151, + 18, + 106, + 16, + 210, + 72, + 96, + 62, + 187, + 98 + ], + "nonce": [ + 170, + 69, + 202, + 93, + 172, + 65, + 168, + 37, + 196, + 93, + 54, + 191 + ], + "aad": [ + 65, + 127, + 213, + 20, + 125, + 86, + 222, + 12, + 116, + 50, + 149, + 151, + 130, + 78, + 194, + 120, + 138, + 52, + 79, + 182, + 11, + 64, + 62, + 223, + 1, + 135, + 175, + 161, + 46, + 114, + 160, + 80, + 9, + 187, + 112, + 248, + 60, + 202, + 209, + 30, + 250, + 72, + 124, + 25, + 101, + 207, + 132, + 254, + 172, + 6, + 124, + 31, + 253, + 191, + 83, + 31, + 202, + 151, + 197, + 84, + 248, + 117, + 196, + 161, + 161, + 211, + 171, + 60, + 83, + 200, + 167, + 78, + 243, + 238, + 148, + 21, + 168, + 126, + 35, + 22, + 153, + 200, + 45, + 118, + 77, + 235, + 237, + 161, + 129, + 50 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 153, + 123, + 248, + 70, + 84, + 187, + 150, + 22, + 192, + 204, + 155, + 69, + 248, + 44, + 118, + 115 + ] + }, + { + "key": [ + 114, + 181, + 132, + 142, + 209, + 210, + 186, + 219, + 212, + 39, + 225, + 111, + 195, + 179, + 228, + 77 + ], + "nonce": [ + 168, + 76, + 126, + 146, + 141, + 198, + 230, + 55, + 154, + 81, + 58, + 32 + ], + "aad": [ + 28, + 13, + 252, + 236, + 189, + 123, + 176, + 230, + 128, + 206, + 4, + 45, + 8, + 178, + 217, + 167, + 65, + 38, + 123, + 209, + 218, + 118, + 141, + 242, + 186, + 8, + 55, + 146, + 51, + 169, + 151, + 63, + 20, + 146, + 142, + 157, + 166, + 53, + 55, + 104, + 185, + 178, + 96, + 28, + 3, + 63, + 217, + 100, + 177, + 106, + 22, + 218, + 170, + 62, + 163, + 90, + 215, + 206, + 247, + 227, + 30, + 177, + 247, + 52, + 10, + 163, + 78, + 139, + 252, + 8, + 176, + 166, + 230, + 32, + 82, + 146, + 87, + 12, + 237, + 67, + 49, + 104, + 118, + 208, + 212, + 153, + 217, + 25, + 46, + 107 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 39, + 12, + 215, + 134, + 185, + 94, + 104, + 32, + 205, + 182, + 90, + 35, + 27, + 117, + 48, + 237 + ] + }, + { + "key": [ + 109, + 5, + 18, + 235, + 242, + 231, + 61, + 99, + 244, + 40, + 73, + 197, + 127, + 7, + 63, + 208 + ], + "nonce": [ + 193, + 196, + 105, + 39, + 199, + 76, + 3, + 241, + 147, + 66, + 195, + 58 + ], + "aad": [ + 40, + 191, + 137, + 3, + 178, + 223, + 183, + 230, + 159, + 26, + 115, + 81, + 33, + 199, + 239, + 233, + 164, + 196, + 43, + 106, + 41, + 83, + 39, + 188, + 235, + 2, + 70, + 200, + 93, + 120, + 44, + 230, + 43, + 240, + 117, + 219, + 223, + 110, + 142, + 198, + 88, + 156, + 38, + 211, + 6, + 150, + 204, + 206, + 239, + 3, + 135, + 11, + 208, + 171, + 253, + 38, + 211, + 6, + 0, + 234, + 252, + 101, + 97, + 55, + 64, + 181, + 77, + 119, + 125, + 55, + 158, + 138, + 172, + 242, + 65, + 236, + 251, + 161, + 27, + 6, + 1, + 134, + 172, + 6, + 93, + 177, + 113, + 170, + 176, + 153 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 166, + 134, + 245, + 148, + 28, + 235, + 81, + 14, + 18, + 106, + 99, + 22, + 227, + 64, + 77, + 192 + ] + }, + { + "key": [ + 100, + 56, + 188, + 121, + 82, + 13, + 239, + 93, + 181, + 142, + 73, + 99, + 151, + 116, + 104, + 122 + ], + "nonce": [ + 214, + 130, + 180, + 116, + 24, + 206, + 181, + 188, + 9, + 199, + 19, + 194 + ], + "aad": [ + 210, + 82, + 177, + 100, + 174, + 85, + 158, + 209, + 85, + 200, + 65, + 123, + 150, + 101, + 37, + 41, + 223, + 21, + 31, + 36, + 204, + 241, + 206, + 152, + 208, + 199, + 221, + 242, + 147, + 244, + 241, + 35, + 102, + 48, + 161, + 155, + 36, + 220, + 35, + 151, + 141, + 51, + 119, + 160, + 153, + 6, + 93, + 11, + 167, + 29, + 75, + 184, + 167, + 220, + 12, + 183, + 103, + 96, + 202, + 124, + 74, + 14, + 18, + 200, + 203, + 86, + 198, + 16, + 38, + 70, + 50, + 60, + 8, + 196, + 244, + 245, + 98, + 38, + 253, + 91, + 113, + 168, + 69, + 144, + 145, + 58, + 210, + 13, + 162, + 135 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 4, + 231, + 135, + 150, + 219, + 244, + 46, + 159, + 250, + 107, + 185, + 227, + 70, + 88, + 31, + 19 + ] + }, + { + "key": [ + 17, + 122, + 10, + 165, + 146, + 255, + 241, + 122, + 227, + 108, + 148, + 145, + 125, + 177, + 108, + 101 + ], + "nonce": [ + 195, + 83, + 123, + 230, + 2, + 157, + 84, + 255, + 239, + 171, + 39, + 48 + ], + "aad": [ + 41, + 233, + 89, + 185, + 104, + 23, + 84, + 122, + 224, + 107, + 248, + 95, + 225, + 100, + 232, + 42, + 38, + 147, + 248, + 42, + 122, + 235, + 102, + 213, + 53, + 240, + 210, + 195, + 191, + 253, + 27, + 161, + 142, + 148, + 239, + 69, + 121, + 57, + 240, + 192, + 115, + 62, + 218, + 71, + 56, + 209, + 54, + 56, + 15, + 200, + 118, + 7, + 92, + 73, + 67, + 34, + 2, + 55, + 165, + 146, + 155, + 1, + 179, + 45, + 162, + 188, + 42, + 106, + 253, + 106, + 225, + 216, + 159, + 212, + 112, + 9, + 56, + 53, + 150, + 47, + 246, + 112, + 139, + 179, + 155, + 163, + 101, + 32, + 47, + 86 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 184, + 127, + 204, + 77, + 92, + 72, + 78, + 104, + 234, + 82, + 192, + 27, + 85, + 255, + 164, + 56 + ] + }, + { + "key": [ + 93, + 153, + 90, + 51, + 142, + 214, + 15, + 138, + 176, + 181, + 157, + 166, + 201, + 164, + 12, + 82 + ], + "nonce": [ + 39, + 35, + 197, + 78, + 49, + 197, + 197, + 127, + 2, + 54, + 232, + 22 + ], + "aad": [ + 35, + 156, + 128, + 104, + 63, + 235, + 106, + 253, + 56, + 248, + 117, + 154, + 39, + 203, + 95, + 53, + 15, + 188, + 47, + 117, + 120, + 56, + 196, + 8, + 88, + 201, + 208, + 143, + 105, + 156, + 197, + 108, + 66, + 54, + 244, + 167, + 123, + 216, + 13, + 240, + 232, + 228, + 29, + 95, + 155, + 167, + 50, + 219, + 46, + 10, + 58, + 94, + 149, + 46, + 222, + 123, + 253, + 213, + 252, + 190, + 189, + 35, + 208, + 114, + 113, + 19, + 77, + 181, + 184, + 36, + 97, + 83, + 124, + 71, + 226, + 202, + 81, + 179, + 72, + 176, + 131, + 15, + 94, + 229, + 117, + 173, + 75, + 68, + 20, + 220 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 148, + 53, + 106, + 59, + 250, + 240, + 127, + 46, + 240, + 235, + 227, + 165, + 7, + 7, + 107, + 22 + ] + }, + { + "key": [ + 200, + 168, + 99, + 161, + 235, + 175, + 16, + 192, + 252, + 14, + 128, + 223, + 18, + 68, + 78, + 110 + ], + "nonce": [ + 195, + 232, + 205, + 240, + 134, + 130, + 127, + 238, + 112, + 149, + 208, + 234 + ], + "aad": [ + 153, + 39, + 218, + 136, + 197, + 211, + 54, + 37, + 102, + 153, + 199, + 104, + 69, + 233, + 70, + 220, + 83, + 200, + 123, + 240, + 225, + 30, + 75, + 236, + 148, + 80, + 152, + 22, + 2, + 179, + 32, + 16, + 210, + 181, + 43, + 252, + 145, + 40, + 58, + 99, + 41, + 212, + 85, + 89, + 137, + 152, + 237, + 226, + 230, + 30, + 53, + 46, + 85, + 49, + 16, + 21, + 75, + 77, + 165, + 206, + 102, + 141, + 102, + 75, + 131, + 246, + 113, + 192, + 16, + 191, + 34, + 11, + 125, + 50, + 179, + 79, + 76, + 166, + 155, + 102, + 204, + 135, + 35, + 61, + 121, + 35, + 55, + 203, + 43, + 255 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 9, + 136, + 55, + 222, + 39, + 112, + 126, + 163, + 89, + 62, + 49, + 206, + 184, + 39, + 103, + 50 + ] + }, + { + "key": [ + 105, + 204, + 40, + 177, + 97, + 242, + 20, + 165, + 128, + 230, + 186, + 75, + 194, + 227, + 222, + 157 + ], + "nonce": [ + 242, + 165, + 102, + 249, + 207, + 131, + 253, + 40, + 12, + 143, + 224, + 142 + ], + "aad": [ + 248, + 197, + 38, + 58, + 78, + 6, + 180, + 158, + 24, + 69, + 137, + 161, + 224, + 113, + 151, + 134, + 67, + 195, + 83, + 170, + 39, + 180, + 129, + 127, + 227, + 158, + 69, + 171, + 196, + 66, + 226, + 42, + 181, + 214, + 131, + 188, + 238, + 93, + 187, + 213, + 137, + 250, + 88, + 63, + 23, + 27, + 181, + 149, + 54, + 173, + 221, + 43, + 108, + 239, + 212, + 152, + 35, + 65, + 48, + 5, + 239, + 178, + 166, + 101, + 226, + 106, + 96, + 41, + 201, + 39, + 211, + 137, + 28, + 176, + 212, + 242, + 62, + 140, + 204, + 96, + 207, + 208, + 44, + 232, + 151, + 140, + 69, + 29, + 220, + 17 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 201, + 200, + 6, + 203, + 139, + 26, + 136, + 152, + 9, + 105, + 92, + 46, + 197, + 167, + 168, + 110 + ] + }, + { + "key": [ + 187, + 243, + 89, + 32, + 252, + 171, + 44, + 237, + 170, + 253, + 243, + 240, + 3, + 33, + 245, + 68 + ], + "nonce": [ + 44, + 126, + 227, + 255, + 29, + 248, + 79, + 54, + 80, + 188, + 146, + 152 + ], + "aad": [ + 167, + 95, + 80, + 186, + 154, + 80, + 244, + 135, + 153, + 89, + 75, + 97, + 149, + 179, + 18, + 94, + 217, + 45, + 247, + 49, + 68, + 191, + 203, + 98, + 76, + 230, + 115, + 35, + 216, + 52, + 186, + 26, + 250, + 240, + 223, + 76, + 108, + 2, + 44, + 17, + 212, + 139, + 215, + 92, + 134, + 103, + 90, + 89, + 39, + 172, + 18, + 80, + 3, + 15, + 114, + 15, + 151, + 73, + 141, + 79, + 224, + 120, + 123, + 174, + 101, + 93, + 197, + 83, + 122, + 193, + 188, + 172, + 25, + 138, + 137, + 63, + 154, + 247, + 194, + 239, + 155, + 151, + 29, + 214, + 79, + 126, + 123, + 98, + 96, + 62 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 199, + 205, + 63, + 147, + 143, + 74, + 177, + 134, + 66, + 216, + 98, + 52, + 237, + 252, + 23, + 237 + ] + }, + { + "key": [ + 150, + 144, + 222, + 102, + 151, + 2, + 186, + 114, + 174, + 185, + 52, + 245, + 172, + 80, + 224, + 60 + ], + "nonce": [ + 218, + 135, + 19, + 254, + 43, + 32, + 88, + 196, + 56, + 175, + 242, + 96 + ], + "aad": [ + 243, + 14, + 233, + 80, + 218, + 55, + 199, + 34, + 75, + 92, + 147, + 233, + 162, + 156, + 175, + 219, + 248, + 226, + 7, + 15, + 101, + 194, + 38, + 36, + 75, + 26, + 104, + 52, + 89, + 224, + 197, + 193, + 28, + 155, + 119, + 200, + 252, + 40, + 109, + 66, + 152, + 165, + 185, + 205, + 31, + 238, + 62, + 19, + 212, + 105, + 10, + 136, + 120, + 13, + 53, + 181, + 88, + 181, + 217, + 229, + 43, + 26, + 103, + 252, + 136, + 87, + 7, + 102, + 145, + 220, + 167, + 245, + 254, + 142, + 242, + 32, + 101, + 204, + 93, + 156, + 0, + 63, + 253, + 37, + 235, + 226, + 62, + 97, + 68, + 14 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 127, + 146, + 145, + 69, + 24, + 221, + 190, + 132, + 43, + 6, + 119, + 31, + 100, + 196, + 15, + 89 + ] + }, + { + "key": [ + 229, + 216, + 198, + 226, + 172, + 105, + 53, + 200, + 94, + 129, + 238, + 14, + 247, + 35, + 234, + 207 + ], + "nonce": [ + 199, + 49, + 64, + 238, + 144, + 204, + 29, + 207, + 136, + 69, + 125, + 162 + ], + "aad": [ + 246, + 194, + 103, + 166, + 174, + 92, + 227, + 207, + 75, + 205, + 245, + 156, + 253, + 31, + 119, + 124, + 102, + 19, + 62, + 14, + 196, + 119, + 39, + 133, + 243, + 62, + 95, + 168, + 0, + 211, + 16, + 178, + 75, + 87, + 115, + 188, + 96, + 58, + 118, + 179, + 15, + 195, + 35, + 40, + 168, + 228, + 15, + 2, + 248, + 35, + 168, + 19, + 169, + 228, + 180, + 250, + 199, + 38, + 233, + 146, + 193, + 131, + 189, + 8, + 21, + 17, + 28, + 29, + 58, + 53, + 136, + 74, + 78, + 255, + 50, + 2, + 123, + 166, + 13, + 186, + 103, + 155, + 70, + 154, + 243, + 27, + 197, + 12, + 5, + 145 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 249, + 56, + 253, + 13, + 140, + 20, + 141, + 129, + 118, + 81, + 9, + 223, + 102, + 218, + 201, + 170 + ] + }, + { + "key": [ + 226, + 52, + 88, + 246, + 179, + 4, + 194, + 216, + 254, + 179, + 222, + 221, + 55, + 65, + 188, + 36 + ], + "nonce": [ + 70, + 25, + 3, + 107, + 80, + 186, + 1, + 47, + 229, + 11, + 225, + 215 + ], + "aad": [ + 116, + 191, + 220, + 107, + 196, + 191, + 195, + 141, + 102, + 107, + 152, + 92, + 254, + 4, + 60, + 103, + 121, + 139, + 45, + 185, + 143, + 20, + 146, + 104, + 219, + 162, + 68, + 54, + 202, + 184, + 62, + 154, + 145, + 242, + 68, + 255, + 197, + 116, + 140, + 147, + 248, + 223, + 51, + 154, + 226, + 75, + 164, + 49, + 140, + 80, + 218, + 1, + 26, + 179, + 104, + 211, + 22, + 124, + 22, + 229, + 3, + 48, + 155, + 1, + 53, + 26, + 17, + 241, + 77, + 6, + 124, + 198, + 118, + 155, + 153, + 137, + 199, + 217, + 82, + 227, + 49, + 80, + 17, + 238, + 46, + 160, + 52, + 219, + 140, + 184 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 96, + 83, + 171, + 128, + 199, + 70, + 130, + 30, + 197, + 12, + 151, + 229, + 161, + 66, + 74, + 133 + ] + }, + { + "key": [ + 83, + 114, + 172, + 93, + 59, + 8, + 216, + 96, + 145, + 145, + 16, + 189, + 235, + 127, + 49, + 223 + ], + "nonce": [ + 6, + 202, + 151, + 157, + 140, + 37, + 13, + 155, + 123, + 228, + 85, + 115 + ], + "aad": [ + 225, + 249, + 88, + 131, + 78, + 99, + 199, + 92, + 140, + 117, + 139, + 175, + 170, + 47, + 37, + 126, + 165, + 104, + 157, + 13, + 85, + 184, + 119, + 180, + 214, + 123, + 139, + 115, + 194, + 92, + 226, + 78, + 155, + 9, + 75, + 151, + 109, + 185, + 32, + 161, + 89, + 150, + 141, + 169, + 211, + 60, + 81, + 26, + 168, + 153, + 154, + 186, + 66, + 184, + 187, + 136, + 110, + 101, + 69, + 221, + 16, + 134, + 147, + 21, + 10, + 243, + 87, + 73, + 107, + 181, + 137, + 139, + 78, + 143, + 114, + 93, + 80, + 239, + 71, + 74, + 251, + 131, + 106, + 51, + 88, + 218, + 34, + 23, + 187, + 147 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 147, + 56, + 225, + 79, + 224, + 176, + 138, + 150, + 154, + 16, + 76, + 130, + 133, + 40, + 166, + 164 + ] + }, + { + "key": [ + 191, + 28, + 180, + 158, + 152, + 12, + 236, + 11, + 21, + 63, + 227, + 87, + 56, + 117, + 172, + 108 + ], + "nonce": [ + 84, + 38, + 102, + 157, + 37, + 82, + 64, + 54, + 251, + 232, + 30, + 137 + ], + "aad": [ + 179, + 54, + 148, + 151, + 102, + 233, + 148, + 138, + 126, + 111, + 54, + 162, + 211, + 119, + 184, + 74, + 37, + 196, + 180, + 152, + 135, + 148, + 243, + 222, + 171, + 122, + 244, + 177, + 74, + 18, + 218, + 198, + 65, + 226, + 95, + 226, + 174, + 159, + 245, + 52, + 80, + 172, + 225, + 81, + 58, + 205, + 11, + 40, + 74, + 73, + 11, + 69, + 95, + 4, + 244, + 10, + 249, + 68, + 24, + 200, + 121, + 46, + 193, + 160, + 152, + 63, + 177, + 217, + 163, + 29, + 147, + 220, + 62, + 210, + 199, + 94, + 106, + 108, + 224, + 146, + 17, + 30, + 171, + 173, + 3, + 155, + 172, + 42, + 73, + 246 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 226, + 153, + 106, + 43, + 59, + 107, + 245, + 34, + 23, + 207, + 196, + 208, + 245, + 187, + 53, + 27 + ] + }, + { + "key": [ + 127, + 221, + 181, + 116, + 83, + 194, + 65, + 208, + 62, + 251, + 237, + 58, + 196, + 78, + 55, + 28 + ], + "nonce": [ + 238, + 40, + 58, + 63, + 199, + 85, + 117, + 227, + 62, + 253, + 72, + 135 + ], + "aad": [], + "plaintext": [ + 213, + 222, + 66, + 180, + 97, + 100, + 108, + 37, + 92, + 135, + 189, + 41, + 98, + 211, + 185, + 162 + ], + "ciphertext": [ + 44, + 205, + 164, + 165, + 65, + 92, + 185, + 30, + 19, + 92, + 42, + 15, + 120, + 201, + 178, + 253 + ], + "tag": [ + 179, + 109, + 29, + 249, + 185, + 213, + 229, + 150, + 248, + 62, + 139, + 127, + 82, + 151, + 28, + 179 + ] + }, + { + "key": [ + 171, + 114, + 199, + 123, + 151, + 203, + 95, + 233, + 163, + 130, + 217, + 254, + 129, + 255, + 219, + 237 + ], + "nonce": [ + 84, + 204, + 125, + 194, + 195, + 126, + 192, + 6, + 188, + 198, + 209, + 218 + ], + "aad": [], + "plaintext": [ + 0, + 124, + 94, + 91, + 62, + 89, + 223, + 36, + 167, + 195, + 85, + 88, + 79, + 193, + 81, + 141 + ], + "ciphertext": [ + 14, + 27, + 222, + 32, + 106, + 7, + 169, + 194, + 193, + 182, + 83, + 0, + 248, + 198, + 73, + 151 + ], + "tag": [ + 43, + 68, + 1, + 52, + 102, + 151, + 19, + 140, + 122, + 72, + 145, + 238, + 89, + 134, + 125, + 12 + ] + }, + { + "key": [ + 119, + 176, + 165, + 138, + 30, + 96, + 84, + 30, + 94, + 163, + 212, + 212, + 32, + 7, + 148, + 14 + ], + "nonce": [ + 174, + 122, + 39, + 144, + 77, + 149, + 254, + 128, + 14, + 131, + 179, + 69 + ], + "aad": [], + "plaintext": [ + 105, + 49, + 163, + 234, + 7, + 169, + 233, + 82, + 7, + 51, + 79, + 2, + 116, + 164, + 84, + 221 + ], + "ciphertext": [ + 118, + 227, + 159, + 173, + 64, + 0, + 160, + 125, + 53, + 216, + 121, + 183, + 133, + 189, + 127, + 202 + ], + "tag": [ + 92, + 179, + 114, + 71, + 18, + 241, + 41, + 248, + 107, + 121, + 39, + 241, + 59, + 69, + 200, + 53 + ] + }, + { + "key": [ + 202, + 170, + 63, + 111, + 211, + 24, + 34, + 237, + 45, + 33, + 37, + 242, + 37, + 176, + 22, + 159 + ], + "nonce": [ + 127, + 109, + 144, + 65, + 72, + 62, + 140, + 20, + 18, + 250, + 85, + 42 + ], + "aad": [], + "plaintext": [ + 132, + 201, + 7, + 177, + 26, + 227, + 183, + 159, + 196, + 69, + 29, + 27, + 241, + 127, + 74, + 153 + ], + "ciphertext": [ + 253, + 180, + 170, + 250, + 53, + 25, + 211, + 192, + 85, + 190, + 139, + 52, + 119, + 100, + 234, + 51 + ], + "tag": [ + 137, + 228, + 59, + 254, + 173, + 1, + 105, + 44, + 78, + 190, + 101, + 101, + 134, + 227, + 251, + 227 + ] + }, + { + "key": [ + 2, + 200, + 232, + 29, + 235, + 197, + 99, + 233, + 156, + 210, + 98, + 191, + 198, + 75, + 14, + 17 + ], + "nonce": [ + 180, + 144, + 87, + 201, + 119, + 141, + 140, + 2, + 254, + 0, + 208, + 41 + ], + "aad": [], + "plaintext": [ + 202, + 42, + 81, + 233, + 208, + 94, + 150, + 230, + 241, + 209, + 76, + 237, + 54, + 129, + 28, + 92 + ], + "ciphertext": [ + 93, + 182, + 2, + 251, + 49, + 187, + 146, + 104, + 210, + 51, + 190, + 224, + 221, + 107, + 135, + 174 + ], + "tag": [ + 120, + 157, + 43, + 226, + 204, + 112, + 183, + 195, + 137, + 179, + 25, + 18, + 225, + 192, + 160, + 65 + ] + }, + { + "key": [ + 78, + 98, + 90, + 62, + 220, + 97, + 240, + 203, + 47, + 0, + 45, + 168, + 248, + 167, + 2, + 69 + ], + "nonce": [ + 102, + 214, + 50, + 221, + 92, + 161, + 11, + 8, + 212, + 216, + 249, + 123 + ], + "aad": [], + "plaintext": [ + 11, + 118, + 212, + 152, + 173, + 214, + 224, + 156, + 150, + 215, + 105, + 78, + 93, + 98, + 11, + 213 + ], + "ciphertext": [ + 23, + 189, + 199, + 239, + 86, + 73, + 190, + 201, + 207, + 108, + 86, + 92, + 227, + 60, + 248, + 137 + ], + "tag": [ + 63, + 121, + 68, + 186, + 208, + 98, + 96, + 95, + 147, + 127, + 246, + 214, + 89, + 138, + 118, + 81 + ] + }, + { + "key": [ + 65, + 171, + 63, + 196, + 136, + 248, + 212, + 168, + 32, + 230, + 91, + 157, + 65, + 168, + 125, + 227 + ], + "nonce": [ + 155, + 93, + 39, + 215, + 90, + 5, + 113, + 233, + 63, + 88, + 24, + 133 + ], + "aad": [], + "plaintext": [ + 94, + 208, + 131, + 110, + 10, + 82, + 119, + 117, + 153, + 128, + 13, + 79, + 231, + 84, + 204, + 190 + ], + "ciphertext": [ + 136, + 192, + 235, + 140, + 51, + 161, + 10, + 34, + 231, + 86, + 24, + 102, + 86, + 107, + 25, + 31 + ], + "tag": [ + 131, + 232, + 133, + 128, + 42, + 89, + 74, + 139, + 0, + 138, + 148, + 170, + 126, + 240, + 105, + 7 + ] + }, + { + "key": [ + 0, + 71, + 24, + 66, + 64, + 165, + 148, + 142, + 213, + 87, + 1, + 234, + 194, + 196, + 194, + 108 + ], + "nonce": [ + 163, + 171, + 141, + 162, + 38, + 72, + 194, + 69, + 60, + 222, + 245, + 91 + ], + "aad": [], + "plaintext": [ + 137, + 238, + 149, + 2, + 135, + 27, + 225, + 94, + 228, + 168, + 196, + 122, + 177, + 35, + 191, + 201 + ], + "ciphertext": [ + 139, + 92, + 181, + 158, + 122, + 210, + 225, + 92, + 64, + 213, + 251, + 205, + 226, + 138, + 13, + 23 + ], + "tag": [ + 83, + 142, + 121, + 248, + 128, + 226, + 246, + 92, + 114, + 20, + 143, + 90, + 222, + 64, + 128, + 161 + ] + }, + { + "key": [ + 115, + 92, + 90, + 79, + 242, + 67, + 136, + 82, + 223, + 53, + 48, + 194, + 53, + 144, + 172, + 40 + ], + "nonce": [ + 123, + 238, + 124, + 105, + 56, + 241, + 174, + 89, + 103, + 30, + 45, + 219 + ], + "aad": [], + "plaintext": [ + 71, + 158, + 141, + 59, + 240, + 222, + 76, + 231, + 205, + 67, + 119, + 210, + 237, + 57, + 37, + 205 + ], + "ciphertext": [ + 44, + 160, + 155, + 88, + 23, + 143, + 187, + 251, + 130, + 85, + 101, + 153, + 185, + 35, + 41, + 163 + ], + "tag": [ + 46, + 60, + 242, + 137, + 95, + 17, + 30, + 194, + 168, + 101, + 8, + 195, + 106, + 36, + 228, + 93 + ] + }, + { + "key": [ + 1, + 109, + 187, + 56, + 218, + 167, + 109, + 254, + 125, + 163, + 132, + 235, + 241, + 36, + 3, + 100 + ], + "nonce": [ + 7, + 147, + 239, + 58, + 218, + 120, + 47, + 120, + 201, + 138, + 255, + 227 + ], + "aad": [], + "plaintext": [ + 75, + 52, + 169, + 236, + 87, + 99, + 82, + 75, + 25, + 29, + 86, + 22, + 197, + 71, + 246, + 183 + ], + "ciphertext": [ + 96, + 154, + 163, + 244, + 84, + 27, + 192, + 254, + 153, + 49, + 218, + 173, + 46, + 225, + 93, + 12 + ], + "tag": [ + 51, + 175, + 236, + 89, + 196, + 91, + 175, + 104, + 154, + 94, + 27, + 19, + 174, + 66, + 54, + 25 + ] + }, + { + "key": [ + 45, + 23, + 102, + 7, + 136, + 58, + 250, + 206, + 117, + 1, + 29, + 20, + 129, + 143, + 27, + 230 + ], + "nonce": [ + 2, + 22, + 44, + 54, + 53, + 191, + 109, + 84, + 62, + 28, + 193, + 72 + ], + "aad": [], + "plaintext": [ + 113, + 144, + 90, + 213, + 223, + 96, + 29, + 5, + 110, + 255, + 216, + 13, + 215, + 51, + 54, + 98 + ], + "ciphertext": [ + 27, + 104, + 89, + 142, + 22, + 118, + 210, + 207, + 211, + 122, + 160, + 3, + 150, + 250, + 150, + 118 + ], + "tag": [ + 93, + 6, + 10, + 168, + 167, + 41, + 119, + 77, + 160, + 1, + 170, + 159, + 222, + 242, + 179, + 210 + ] + }, + { + "key": [ + 148, + 253, + 2, + 105, + 160, + 206, + 129, + 49, + 51, + 98, + 111, + 147, + 196, + 175, + 126, + 111 + ], + "nonce": [ + 17, + 252, + 57, + 40, + 2, + 141, + 250, + 52, + 219, + 6, + 161, + 188 + ], + "aad": [], + "plaintext": [ + 161, + 174, + 254, + 201, + 118, + 205, + 135, + 207, + 138, + 76, + 33, + 187, + 233, + 2, + 247, + 180 + ], + "ciphertext": [ + 177, + 186, + 248, + 197, + 140, + 222, + 200, + 130, + 56, + 177, + 176, + 171, + 11, + 64, + 51, + 125 + ], + "tag": [ + 136, + 47, + 134, + 93, + 247, + 218, + 82, + 159, + 118, + 141, + 73, + 68, + 232, + 56, + 127, + 105 + ] + }, + { + "key": [ + 167, + 190, + 197, + 226, + 79, + 13, + 178, + 98, + 154, + 37, + 125, + 2, + 253, + 250, + 234, + 2 + ], + "nonce": [ + 157, + 46, + 201, + 75, + 146, + 115, + 39, + 121, + 53, + 131, + 184, + 24 + ], + "aad": [], + "plaintext": [ + 161, + 123, + 197, + 212, + 40, + 112, + 15, + 148, + 198, + 65, + 231, + 74, + 170, + 207, + 44, + 93 + ], + "ciphertext": [ + 212, + 96, + 253, + 165, + 178, + 68, + 37, + 181, + 202, + 168, + 23, + 108, + 140, + 103, + 179, + 169 + ], + "tag": [ + 13, + 247, + 36, + 52, + 11, + 140, + 165, + 110, + 141, + 234, + 107, + 190, + 180, + 181, + 92, + 53 + ] + }, + { + "key": [ + 57, + 217, + 69, + 160, + 14, + 5, + 215, + 10, + 22, + 230, + 19, + 52, + 210, + 1, + 2, + 9 + ], + "nonce": [ + 31, + 147, + 20, + 72, + 233, + 1, + 62, + 196, + 236, + 97, + 175, + 12 + ], + "aad": [], + "plaintext": [ + 157, + 217, + 14, + 191, + 192, + 84, + 218, + 33, + 76, + 187, + 48, + 219, + 127, + 117, + 198, + 146 + ], + "ciphertext": [ + 228, + 203, + 118, + 84, + 8, + 105, + 124, + 248, + 89, + 23, + 167, + 169, + 38, + 64, + 134, + 228 + ], + "tag": [ + 254, + 154, + 31, + 231, + 165, + 141, + 102, + 227, + 185, + 34, + 105, + 58, + 22, + 60, + 31, + 244 + ] + }, + { + "key": [ + 102, + 32, + 202, + 101, + 247, + 45, + 231, + 184, + 101, + 222, + 115, + 25, + 40, + 164, + 114, + 62 + ], + "nonce": [ + 230, + 66, + 139, + 107, + 119, + 233, + 182, + 153, + 59, + 128, + 154, + 239 + ], + "aad": [], + "plaintext": [ + 112, + 68, + 247, + 194, + 125, + 119, + 111, + 106, + 125, + 67, + 171, + 234, + 53, + 144, + 141, + 228 + ], + "ciphertext": [ + 161, + 197, + 99, + 74, + 7, + 208, + 92, + 169, + 9, + 219, + 168, + 123, + 240, + 34, + 40, + 228 + ], + "tag": [ + 216, + 180, + 10, + 96, + 166, + 82, + 55, + 51, + 125, + 176, + 91, + 4, + 93, + 232, + 7, + 76 + ] + }, + { + "key": [ + 201, + 57, + 204, + 19, + 57, + 124, + 29, + 55, + 222, + 106, + 224, + 225, + 203, + 124, + 66, + 60 + ], + "nonce": [ + 179, + 216, + 204, + 1, + 124, + 187, + 137, + 179, + 158, + 15, + 103, + 226 + ], + "aad": [ + 36, + 130, + 86, + 2, + 189, + 18, + 169, + 132, + 224, + 9, + 45, + 62, + 68, + 142, + 218, + 95 + ], + "plaintext": [ + 195, + 179, + 196, + 31, + 17, + 58, + 49, + 183, + 61, + 154, + 92, + 212, + 50, + 16, + 48, + 105 + ], + "ciphertext": [ + 147, + 254, + 125, + 158, + 155, + 253, + 16, + 52, + 138, + 86, + 6, + 229, + 202, + 250, + 115, + 84 + ], + "tag": [ + 0, + 50, + 161, + 220, + 133, + 241, + 201, + 120, + 105, + 37, + 162, + 231, + 29, + 130, + 114, + 221 + ] + }, + { + "key": [ + 89, + 158, + 182, + 94, + 107, + 42, + 42, + 127, + 204, + 64, + 229, + 28, + 79, + 110, + 50, + 87 + ], + "nonce": [ + 212, + 7, + 48, + 28, + 250, + 41, + 175, + 133, + 37, + 152, + 28, + 23 + ], + "aad": [ + 16, + 231, + 46, + 254, + 4, + 134, + 72, + 212, + 1, + 57, + 71, + 122, + 32, + 22, + 248, + 206 + ], + "plaintext": [ + 166, + 201, + 224, + 242, + 72, + 240, + 122, + 48, + 70, + 236, + 225, + 33, + 37, + 102, + 105, + 33 + ], + "ciphertext": [ + 27, + 233, + 53, + 154, + 84, + 63, + 215, + 236, + 60, + 75, + 198, + 243, + 201, + 57, + 94, + 137 + ], + "tag": [ + 226, + 233, + 192, + 125, + 76, + 60, + 16, + 166, + 19, + 124, + 164, + 51, + 218, + 66, + 249, + 168 + ] + }, + { + "key": [ + 45, + 38, + 84, + 145, + 113, + 47, + 230, + 215, + 8, + 122, + 85, + 69, + 133, + 47, + 79, + 68 + ], + "nonce": [ + 197, + 152, + 104, + 184, + 112, + 31, + 191, + 136, + 230, + 52, + 50, + 98 + ], + "aad": [ + 103, + 16, + 86, + 52, + 172, + 159, + 191, + 132, + 153, + 112, + 220, + 65, + 109, + 231, + 173, + 48 + ], + "plaintext": [ + 48, + 24, + 115, + 190, + 105, + 240, + 90, + 132, + 242, + 36, + 8, + 170, + 8, + 98, + 209, + 154 + ], + "ciphertext": [ + 152, + 176, + 60, + 119, + 166, + 120, + 49, + 188, + 241, + 107, + 29, + 217, + 108, + 50, + 78, + 28 + ], + "tag": [ + 57, + 21, + 46, + 38, + 189, + 196, + 209, + 126, + 140, + 0, + 73, + 63, + 160, + 190, + 146, + 242 + ] + }, + { + "key": [ + 31, + 209, + 229, + 54, + 161, + 195, + 156, + 117, + 253, + 88, + 59, + 200, + 227, + 55, + 32, + 41 + ], + "nonce": [ + 40, + 31, + 37, + 82, + 248, + 195, + 79, + 185, + 179, + 236, + 133, + 170 + ], + "aad": [ + 191, + 18, + 161, + 64, + 216, + 103, + 39, + 246, + 123, + 134, + 11, + 207, + 111, + 52, + 229, + 95 + ], + "plaintext": [ + 248, + 1, + 224, + 131, + 150, + 25, + 210, + 193, + 70, + 95, + 2, + 69, + 134, + 147, + 96, + 218 + ], + "ciphertext": [ + 53, + 55, + 31, + 39, + 121, + 244, + 20, + 13, + 253, + 177, + 175, + 231, + 157, + 86, + 62, + 217 + ], + "tag": [ + 204, + 43, + 11, + 15, + 31, + 139, + 61, + 181, + 220, + 27, + 65, + 206, + 115, + 245, + 194, + 33 + ] + }, + { + "key": [ + 123, + 3, + 69, + 246, + 220, + 244, + 105, + 236, + 249, + 177, + 126, + 250, + 57, + 222, + 83, + 89 + ], + "nonce": [ + 177, + 93, + 111, + 205, + 229, + 230, + 207, + 31, + 169, + 155, + 161, + 69 + ], + "aad": [ + 114, + 233, + 203, + 38, + 136, + 81, + 84, + 212, + 98, + 158, + 123, + 201, + 18, + 121, + 187, + 25 + ], + "plaintext": [ + 130, + 42, + 224, + 26, + 3, + 114, + 182, + 170, + 70, + 194, + 229, + 191, + 25, + 219, + 146, + 242 + ], + "ciphertext": [ + 56, + 46, + 68, + 6, + 148, + 176, + 201, + 59, + 232, + 221, + 67, + 142, + 55, + 99, + 81, + 148 + ], + "tag": [ + 47, + 160, + 66, + 191, + 249, + 169, + 205, + 53, + 227, + 67, + 181, + 32, + 1, + 120, + 65, + 187 + ] + }, + { + "key": [ + 157, + 185, + 26, + 64, + 2, + 12, + 219, + 7, + 248, + 135, + 105, + 48, + 154, + 106, + 196, + 11 + ], + "nonce": [ + 248, + 158, + 27, + 126, + 89, + 140, + 194, + 83, + 90, + 92, + 134, + 89 + ], + "aad": [ + 112, + 145, + 5, + 152, + 231, + 171, + 212, + 240, + 80, + 62, + 205, + 158, + 33, + 189, + 175, + 181 + ], + "plaintext": [ + 244, + 165, + 0, + 61, + 180, + 164, + 235, + 188, + 47, + 219, + 140, + 103, + 86, + 131, + 3, + 145 + ], + "ciphertext": [ + 64, + 215, + 252, + 76, + 204, + 129, + 71, + 88, + 31, + 64, + 101, + 90, + 7, + 242, + 62, + 233 + ], + "tag": [ + 36, + 51, + 49, + 180, + 132, + 4, + 133, + 156, + 102, + 175, + 77, + 123, + 46, + 228, + 65, + 9 + ] + }, + { + "key": [ + 226, + 244, + 131, + 152, + 155, + 52, + 158, + 251, + 89, + 174, + 10, + 124, + 173, + 199, + 75, + 122 + ], + "nonce": [ + 51, + 56, + 52, + 63, + 155, + 151, + 235, + 183, + 132, + 231, + 80, + 39 + ], + "aad": [ + 139, + 18, + 152, + 126, + 96, + 15, + 245, + 141, + 245, + 79, + 31, + 94, + 98, + 229, + 158, + 97 + ], + "plaintext": [ + 20, + 216, + 10, + 214, + 110, + 143, + 95, + 46, + 108, + 67, + 195, + 16, + 158, + 2, + 58, + 147 + ], + "ciphertext": [ + 67, + 194, + 214, + 131, + 132, + 212, + 134, + 233, + 120, + 137, + 80, + 187, + 184, + 205, + 143, + 209 + ], + "tag": [ + 71, + 215, + 233, + 20, + 79, + 240, + 237, + 74, + 163, + 48, + 10, + 148, + 74, + 0, + 120, + 130 + ] + }, + { + "key": [ + 92, + 17, + 85, + 8, + 76, + 192, + 237, + 231, + 107, + 59, + 194, + 46, + 159, + 117, + 116, + 239 + ], + "nonce": [ + 149, + 73, + 228, + 186, + 105, + 166, + 28, + 173, + 120, + 86, + 239, + 193 + ], + "aad": [ + 233, + 142, + 157, + 156, + 97, + 142, + 70, + 254, + 243, + 38, + 96, + 151, + 111, + 133, + 78, + 227 + ], + "plaintext": [ + 209, + 68, + 143, + 168, + 82, + 184, + 68, + 8, + 226, + 218, + 216, + 56, + 31, + 54, + 61, + 231 + ], + "ciphertext": [ + 247, + 139, + 96, + 202, + 18, + 82, + 24, + 73, + 59, + 234, + 28, + 80, + 162, + 225, + 46, + 244 + ], + "tag": [ + 215, + 45, + 167, + 245, + 198, + 207, + 11, + 202, + 114, + 66, + 199, + 24, + 53, + 128, + 148, + 73 + ] + }, + { + "key": [ + 35, + 82, + 80, + 55, + 64, + 164, + 225, + 178, + 45, + 204, + 156, + 0, + 47, + 83, + 189, + 17 + ], + "nonce": [ + 71, + 78, + 204, + 204, + 49, + 130, + 224, + 60, + 128, + 167, + 190, + 116 + ], + "aad": [ + 161, + 188, + 152, + 218, + 206, + 196, + 182, + 170, + 127, + 238, + 109, + 250, + 8, + 2, + 242, + 26 + ], + "plaintext": [ + 220, + 28, + 53, + 188, + 120, + 185, + 133, + 242, + 210, + 177, + 161, + 60, + 230, + 53, + 221, + 105 + ], + "ciphertext": [ + 63, + 111, + 77, + 175, + 109, + 7, + 116, + 59, + 155, + 210, + 160, + 105, + 211, + 113, + 8, + 52 + ], + "tag": [ + 185, + 194, + 179, + 25, + 173, + 189, + 116, + 63, + 94, + 79, + 253, + 68, + 48, + 74, + 27, + 95 + ] + }, + { + "key": [ + 252, + 31, + 151, + 27, + 81, + 74, + 22, + 120, + 101, + 52, + 27, + 130, + 138, + 66, + 149, + 214 + ], + "nonce": [ + 136, + 81, + 234, + 104, + 210, + 12, + 224, + 190, + 255, + 30, + 58, + 152 + ], + "aad": [ + 236, + 232, + 213, + 246, + 58, + 235, + 218, + 128, + 235, + 222, + 75, + 117, + 6, + 55, + 246, + 84 + ], + "plaintext": [ + 47, + 236, + 23, + 177, + 169, + 87, + 15, + 102, + 81, + 187, + 233, + 166, + 87, + 216, + 43, + 206 + ], + "ciphertext": [ + 45, + 39, + 229, + 250, + 8, + 226, + 24, + 240, + 43, + 46, + 54, + 223, + 173, + 135, + 165, + 14 + ], + "tag": [ + 235, + 153, + 102, + 119, + 76, + 88, + 138, + 49, + 183, + 28, + 77, + 141, + 170, + 73, + 94, + 158 + ] + }, + { + "key": [ + 0, + 239, + 60, + 103, + 98, + 190, + 63, + 186, + 179, + 129, + 84, + 217, + 2, + 255, + 67, + 181 + ], + "nonce": [ + 195, + 193, + 195, + 7, + 156, + 218, + 73, + 167, + 90, + 83, + 179, + 204 + ], + "aad": [ + 113, + 79, + 161, + 214, + 144, + 65, + 135, + 179, + 197, + 192, + 138, + 48, + 223, + 252, + 134, + 232 + ], + "plaintext": [ + 190, + 66, + 94, + 0, + 142, + 155, + 12, + 8, + 59, + 25, + 162, + 217, + 69, + 194, + 237, + 233 + ], + "ciphertext": [ + 201, + 97, + 161, + 117, + 141, + 207, + 145, + 229, + 57, + 101, + 131, + 114, + 219, + 24, + 150, + 142 + ], + "tag": [ + 234, + 249, + 189, + 169, + 179, + 50, + 47, + 80, + 31, + 115, + 41, + 203, + 97, + 193, + 196, + 40 + ] + }, + { + "key": [ + 45, + 112, + 185, + 86, + 153, + 67, + 204, + 73, + 205, + 239, + 132, + 149, + 189, + 182, + 240, + 230 + ], + "nonce": [ + 180, + 1, + 208, + 245, + 8, + 128, + 166, + 33, + 31, + 222, + 157, + 156 + ], + "aad": [ + 89, + 46, + 114, + 118, + 189, + 160, + 102, + 50, + 127, + 43, + 60, + 216, + 204, + 57, + 245, + 113 + ], + "plaintext": [ + 71, + 168, + 122, + 56, + 121, + 68, + 247, + 57, + 189, + 60, + 176, + 62, + 14, + 139, + 228, + 153 + ], + "ciphertext": [ + 193, + 178, + 175, + 77, + 39, + 50, + 49, + 231, + 30, + 126, + 6, + 108, + 32, + 107, + 245, + 103 + ], + "tag": [ + 198, + 141, + 141, + 60, + 248, + 184, + 158, + 107, + 21, + 246, + 35, + 214, + 15, + 239, + 96, + 189 + ] + }, + { + "key": [ + 119, + 92, + 183, + 248, + 220, + 115, + 240, + 79, + 228, + 249, + 210, + 33, + 38, + 187, + 123, + 87 + ], + "nonce": [ + 129, + 206, + 177, + 125, + 238, + 225, + 155, + 129, + 83, + 255, + 146, + 124 + ], + "aad": [ + 151, + 224, + 124, + 214, + 80, + 101, + 209, + 237, + 200, + 99, + 25, + 45, + 233, + 139, + 198, + 44 + ], + "plaintext": [ + 130, + 66, + 198, + 192, + 238, + 214, + 213, + 209, + 171, + 105, + 205, + 17, + 219, + 227, + 97, + 208 + ], + "ciphertext": [ + 88, + 15, + 6, + 58, + 177, + 164, + 128, + 29, + 39, + 158, + 78, + 231, + 115, + 32, + 10, + 190 + ], + "tag": [ + 41, + 228, + 215, + 224, + 84, + 166, + 176, + 164, + 224, + 17, + 51, + 87, + 63, + 190, + 99, + 43 + ] + }, + { + "key": [ + 88, + 186, + 60, + 183, + 192, + 160, + 207, + 87, + 117, + 0, + 43, + 243, + 177, + 18, + 208, + 81 + ], + "nonce": [ + 187, + 146, + 60, + 147, + 221, + 202, + 48, + 58, + 177, + 49, + 35, + 141 + ], + "aad": [ + 8, + 152, + 234, + 85, + 192, + 202, + 5, + 148, + 128, + 110, + 45, + 199, + 139, + 225, + 92, + 39 + ], + "plaintext": [ + 107, + 147, + 210, + 217, + 45, + 224, + 91, + 83, + 118, + 158, + 195, + 152, + 171, + 128, + 151, + 220 + ], + "ciphertext": [ + 208, + 86, + 64, + 6, + 177, + 137, + 123, + 242, + 25, + 34, + 254, + 244, + 246, + 56, + 111, + 212 + ], + "tag": [ + 58, + 146, + 243, + 201, + 227, + 174, + 107, + 12, + 105, + 220, + 184, + 134, + 141, + 77, + 226, + 124 + ] + }, + { + "key": [ + 149, + 91, + 118, + 29, + 232, + 233, + 143, + 55, + 172, + 180, + 18, + 89, + 250, + 48, + 132, + 66 + ], + "nonce": [ + 161, + 3, + 219, + 138, + 8, + 37, + 230, + 6, + 183, + 4, + 39, + 252 + ], + "aad": [ + 194, + 208, + 216, + 183, + 122, + 111, + 208, + 60, + 237, + 8, + 14, + 15, + 137, + 222, + 138, + 75 + ], + "plaintext": [ + 209, + 131, + 68, + 200, + 108, + 175, + 252, + 66, + 55, + 210, + 218, + 174, + 71, + 129, + 123, + 19 + ], + "ciphertext": [ + 6, + 93, + 34, + 140, + 18, + 137, + 0, + 122, + 104, + 42, + 168, + 71, + 163, + 107, + 111, + 48 + ], + "tag": [ + 251, + 54, + 127, + 71, + 146, + 45, + 103, + 200, + 75, + 244, + 122, + 171, + 178, + 185, + 132, + 33 + ] + }, + { + "key": [ + 212, + 162, + 36, + 136, + 248, + 221, + 29, + 92, + 108, + 25, + 167, + 214, + 202, + 23, + 150, + 76 + ], + "nonce": [ + 243, + 213, + 131, + 127, + 34, + 172, + 26, + 4, + 37, + 224, + 209, + 213 + ], + "aad": [ + 241, + 197, + 212, + 36, + 184, + 63, + 150, + 198, + 173, + 140, + 178, + 140, + 160, + 210, + 14, + 71, + 94, + 2, + 59, + 90 + ], + "plaintext": [ + 123, + 67, + 1, + 106, + 22, + 137, + 100, + 151, + 251, + 69, + 123, + 230, + 210, + 165, + 65, + 34 + ], + "ciphertext": [ + 194, + 189, + 103, + 238, + 245, + 233, + 92, + 172, + 39, + 227, + 176, + 110, + 48, + 49, + 208, + 168 + ], + "tag": [ + 242, + 62, + 172, + 249, + 209, + 205, + 248, + 115, + 119, + 38, + 197, + 134, + 72, + 130, + 110, + 156 + ] + }, + { + "key": [ + 232, + 137, + 147, + 69, + 228, + 216, + 155, + 118, + 247, + 105, + 93, + 223, + 42, + 36, + 187, + 60 + ], + "nonce": [ + 157, + 250, + 235, + 93, + 115, + 55, + 44, + 235, + 6, + 202, + 123, + 190 + ], + "aad": [ + 254, + 208, + 180, + 90, + 154, + 123, + 7, + 198, + 218, + 84, + 116, + 144, + 127, + 88, + 144, + 227, + 23, + 231, + 74, + 66 + ], + "plaintext": [ + 194, + 128, + 126, + 64, + 62, + 155, + 171, + 246, + 69, + 38, + 140, + 146, + 188, + 157, + 29, + 230 + ], + "ciphertext": [ + 142, + 68, + 191, + 7, + 69, + 66, + 85, + 170, + 158, + 54, + 235, + 52, + 205, + 253, + 0, + 54 + ], + "tag": [ + 47, + 80, + 30, + 82, + 73, + 170, + 89, + 90, + 83, + 225, + 152, + 94, + 144, + 52, + 106, + 34 + ] + }, + { + "key": [ + 193, + 98, + 157, + 99, + 32, + 185, + 218, + 128, + 162, + 60, + 129, + 190, + 83, + 240, + 239, + 87 + ], + "nonce": [ + 184, + 97, + 95, + 111, + 250, + 48, + 102, + 137, + 71, + 85, + 108, + 216 + ], + "aad": [ + 95, + 41, + 85, + 228, + 48, + 24, + 82, + 167, + 6, + 132, + 249, + 120, + 248, + 158, + 122, + 97, + 83, + 31, + 8, + 97 + ], + "plaintext": [ + 101, + 119, + 26, + 181, + 37, + 50, + 201, + 205, + 252, + 179, + 169, + 235, + 123, + 129, + 147, + 223 + ], + "ciphertext": [ + 194, + 167, + 45, + 105, + 49, + 129, + 200, + 25, + 246, + 155, + 66, + 181, + 32, + 136, + 211, + 162 + ], + "tag": [ + 202, + 218, + 238, + 48, + 93, + 139, + 182, + 215, + 2, + 89, + 166, + 80, + 50, + 128, + 217, + 154 + ] + }, + { + "key": [ + 25, + 110, + 215, + 130, + 129, + 187, + 117, + 67, + 214, + 14, + 104, + 204, + 162, + 170, + 169, + 65 + ], + "nonce": [ + 110, + 125, + 44, + 143, + 19, + 87, + 21, + 83, + 42, + 7, + 92, + 80 + ], + "aad": [ + 214, + 252, + 152, + 198, + 50, + 210, + 226, + 100, + 16, + 65, + 255, + 115, + 132, + 217, + 42, + 131, + 88, + 174, + 154, + 190 + ], + "plaintext": [ + 21, + 180, + 46, + 126, + 162, + 26, + 138, + 213, + 220, + 215, + 169, + 187, + 160, + 37, + 61, + 68 + ], + "ciphertext": [ + 6, + 229, + 204, + 129, + 194, + 208, + 34, + 203, + 43, + 93, + 229, + 168, + 129, + 198, + 45, + 9 + ], + "tag": [ + 40, + 232, + 202, + 211, + 52, + 108, + 229, + 131, + 213, + 238, + 186, + 167, + 150, + 229, + 9, + 116 + ] + }, + { + "key": [ + 85, + 254, + 138, + 27, + 220, + 104, + 6, + 237, + 47, + 74, + 132, + 137, + 29, + 185, + 67, + 160 + ], + "nonce": [ + 175, + 77, + 11, + 160, + 169, + 15, + 30, + 113, + 61, + 113, + 174, + 148 + ], + "aad": [ + 103, + 124, + 212, + 230, + 192, + 166, + 121, + 19, + 8, + 93, + 186, + 76, + 194, + 167, + 120, + 184, + 148, + 225, + 116, + 173 + ], + "plaintext": [ + 129, + 49, + 89, + 114, + 240, + 177, + 174, + 170, + 0, + 83, + 99, + 233, + 236, + 160, + 157, + 122 + ], + "ciphertext": [ + 196, + 123, + 203, + 39, + 197, + 168, + 217, + 190, + 177, + 159, + 238, + 56, + 185, + 8, + 97, + 183 + ], + "tag": [ + 224, + 97, + 238, + 72, + 104, + 237, + 242, + 217, + 105, + 232, + 117, + 184, + 104, + 92, + 168, + 169 + ] + }, + { + "key": [ + 109, + 134, + 168, + 85, + 80, + 134, + 87, + 248, + 4, + 9, + 27, + 226, + 41, + 10, + 23, + 224 + ], + "nonce": [ + 101, + 220, + 225, + 138, + 68, + 97, + 175, + 216, + 63, + 20, + 128, + 245 + ], + "aad": [ + 224, + 239, + 143, + 14, + 31, + 68, + 42, + 44, + 9, + 5, + 104, + 210, + 175, + 51, + 110, + 197, + 159, + 87, + 200, + 150 + ], + "plaintext": [ + 4, + 35, + 189, + 28, + 138, + 234, + 148, + 54, + 55, + 199, + 195, + 176, + 202, + 97, + 213, + 75 + ], + "ciphertext": [ + 83, + 80, + 93, + 68, + 147, + 105, + 201, + 188, + 216, + 161, + 56, + 116, + 14, + 166, + 96, + 46 + ], + "tag": [ + 134, + 249, + 40, + 180, + 83, + 40, + 37, + 175, + 156, + 172, + 56, + 32, + 35, + 74, + 254, + 115 + ] + }, + { + "key": [ + 102, + 189, + 123, + 93, + 253, + 10, + 170, + 237, + 139, + 184, + 137, + 14, + 238, + 155, + 156, + 154 + ], + "nonce": [ + 110, + 146, + 191, + 126, + 143, + 208, + 251, + 147, + 36, + 81, + 253, + 242 + ], + "aad": [ + 96, + 69, + 156, + 104, + 27, + 218, + 99, + 30, + 206, + 26, + 172, + 202, + 74, + 123, + 27, + 54, + 156, + 86, + 210, + 187 + ], + "plaintext": [ + 128, + 5, + 134, + 92, + 135, + 148, + 183, + 150, + 18, + 68, + 127, + 94, + 243, + 51, + 151, + 208 + ], + "ciphertext": [ + 131, + 185, + 146, + 83, + 222, + 5, + 98, + 90, + 168, + 230, + 132, + 144, + 187, + 54, + 139, + 185 + ], + "tag": [ + 101, + 212, + 68, + 176, + 42, + 35, + 232, + 84, + 168, + 84, + 35, + 33, + 117, + 98, + 208, + 127 + ] + }, + { + "key": [ + 231, + 232, + 37, + 112, + 124, + 91, + 124, + 207, + 108, + 252, + 0, + 157, + 209, + 52, + 241, + 102 + ], + "nonce": [ + 221, + 12, + 122, + 156, + 104, + 209, + 78, + 7, + 63, + 22, + 167, + 160 + ], + "aad": [ + 17, + 198, + 158, + 209, + 135, + 241, + 101, + 22, + 6, + 131, + 231, + 240, + 16, + 48, + 56, + 183, + 117, + 18, + 70, + 11 + ], + "plaintext": [ + 136, + 177, + 177, + 30, + 71, + 223, + 226, + 248, + 16, + 150, + 195, + 96, + 207, + 30, + 48, + 231 + ], + "ciphertext": [ + 85, + 15, + 164, + 153, + 167, + 203, + 71, + 131, + 193, + 149, + 114, + 136, + 165, + 204, + 85, + 127 + ], + "tag": [ + 93, + 44, + 47, + 113, + 162, + 230, + 173, + 155, + 48, + 1, + 189, + 191, + 4, + 105, + 0, + 147 + ] + }, + { + "key": [ + 146, + 89, + 27, + 21, + 226, + 140, + 228, + 113, + 49, + 108, + 87, + 95, + 57, + 99, + 16, + 58 + ], + "nonce": [ + 44, + 48, + 210, + 21, + 229, + 201, + 80, + 241, + 254, + 145, + 132, + 246 + ], + "aad": [ + 70, + 225, + 189, + 95, + 166, + 70, + 228, + 96, + 94, + 47, + 190, + 199, + 0, + 250, + 89, + 42, + 113, + 75, + 199, + 239 + ], + "plaintext": [ + 220, + 136, + 66, + 179, + 193, + 70, + 103, + 134, + 39, + 96, + 7, + 66, + 18, + 110, + 167, + 20 + ], + "ciphertext": [ + 165, + 65, + 211, + 216, + 240, + 121, + 191, + 224, + 83, + 186, + 136, + 53, + 224, + 43, + 52, + 157 + ], + "tag": [ + 211, + 34, + 169, + 36, + 191, + 68, + 128, + 156, + 184, + 207, + 232, + 196, + 185, + 114, + 163, + 7 + ] + }, + { + "key": [ + 116, + 240, + 131, + 83, + 212, + 19, + 157, + 218, + 212, + 102, + 145, + 218, + 136, + 142, + 232, + 151 + ], + "nonce": [ + 226, + 97, + 146, + 23, + 220, + 139, + 9, + 62, + 44, + 124, + 91, + 120 + ], + "aad": [ + 146, + 39, + 124, + 247, + 138, + 190, + 36, + 114, + 12, + 226, + 25, + 187, + 163, + 167, + 163, + 57, + 162, + 224, + 17, + 178 + ], + "plaintext": [ + 22, + 144, + 214, + 200, + 249, + 94, + 245, + 172, + 53, + 197, + 110, + 49, + 41, + 113, + 123, + 68 + ], + "ciphertext": [ + 180, + 19, + 85, + 124, + 13, + 242, + 158, + 48, + 114, + 187, + 27, + 50, + 110, + 32, + 2, + 220 + ], + "tag": [ + 59, + 182, + 39, + 54, + 135, + 236, + 106, + 63, + 74, + 3, + 102, + 241, + 181, + 75, + 211, + 24 + ] + }, + { + "key": [ + 92, + 149, + 28, + 208, + 56, + 163, + 198, + 92, + 214, + 83, + 37, + 191, + 221, + 232, + 105, + 100 + ], + "nonce": [ + 59, + 245, + 98, + 63, + 209, + 21, + 95, + 16, + 54, + 234, + 137, + 63 + ], + "aad": [ + 220, + 52, + 1, + 69, + 19, + 253, + 14, + 237, + 232, + 233, + 202, + 68, + 161, + 110, + 64, + 10, + 95, + 137, + 205, + 208 + ], + "plaintext": [ + 182, + 9, + 236, + 102, + 115, + 227, + 148, + 23, + 109, + 217, + 130, + 185, + 129, + 165, + 67, + 107 + ], + "ciphertext": [ + 0, + 156, + 246, + 35, + 229, + 122, + 49, + 41, + 98, + 106, + 48, + 72, + 155, + 115, + 6, + 7 + ], + "tag": [ + 29, + 32, + 40, + 37, + 219, + 129, + 60, + 15, + 197, + 33, + 194, + 132, + 221, + 84, + 63, + 255 + ] + }, + { + "key": [ + 114, + 48, + 28, + 9, + 59, + 168, + 4, + 103, + 28, + 68, + 166, + 191, + 82, + 131, + 157, + 156 + ], + "nonce": [ + 135, + 204, + 126, + 101, + 121, + 204, + 146, + 130, + 47, + 87, + 68, + 246 + ], + "aad": [ + 244, + 97, + 148, + 108, + 79, + 235, + 167, + 156, + 24, + 54, + 101, + 85, + 216, + 83, + 17, + 36, + 141, + 38, + 156, + 135 + ], + "plaintext": [ + 213, + 155, + 186, + 228, + 255, + 62, + 55, + 85, + 192, + 166, + 26, + 155, + 109, + 62, + 35, + 76 + ], + "ciphertext": [ + 238, + 116, + 61, + 41, + 220, + 186, + 160, + 132, + 253, + 169, + 30, + 180, + 139, + 59, + 233, + 97 + ], + "tag": [ + 7, + 147, + 74, + 83, + 114, + 212, + 25, + 40, + 242, + 238, + 125, + 75, + 184, + 193, + 137, + 130 + ] + }, + { + "key": [ + 57, + 180, + 248, + 38, + 181, + 32, + 131, + 9, + 65, + 179, + 177, + 188, + 213, + 126, + 65, + 213 + ], + "nonce": [ + 202, + 50, + 172, + 82, + 63, + 231, + 223, + 239, + 228, + 21, + 203, + 161 + ], + "aad": [ + 197, + 134, + 205, + 147, + 155, + 39, + 130, + 22, + 149, + 180, + 238, + 77, + 215, + 153, + 251, + 14, + 52, + 73, + 168, + 14 + ], + "plaintext": [ + 170, + 43, + 122, + 108, + 145, + 142, + 214, + 113, + 84, + 65, + 208, + 70, + 133, + 139, + 82, + 95 + ], + "ciphertext": [ + 139, + 100, + 245, + 234, + 154, + 140, + 181, + 33, + 198, + 109, + 249, + 199, + 77, + 75, + 126, + 205 + ], + "tag": [ + 61, + 181, + 106, + 121, + 43, + 103, + 172, + 109, + 12, + 64, + 1, + 225, + 127, + 68, + 97, + 17 + ] + }, + { + "key": [ + 121, + 68, + 158, + 95, + 103, + 13, + 85, + 238, + 45, + 145, + 202, + 153, + 74, + 38, + 122, + 140 + ], + "nonce": [ + 199, + 121, + 218, + 0, + 214, + 114, + 129, + 29, + 138, + 81, + 36, + 241 + ], + "aad": [ + 84, + 120, + 8, + 70, + 220, + 61, + 247, + 124, + 141, + 144, + 201, + 242, + 222, + 203, + 7, + 56, + 218, + 54, + 251, + 218 + ], + "plaintext": [ + 118, + 126, + 18, + 13, + 235, + 216, + 161, + 220, + 141, + 45, + 184, + 183, + 244, + 117, + 7, + 65 + ], + "ciphertext": [ + 235, + 134, + 68, + 18, + 173, + 208, + 138, + 187, + 79, + 137, + 215, + 45, + 65, + 45, + 0, + 133 + ], + "tag": [ + 73, + 74, + 84, + 127, + 97, + 120, + 64, + 38, + 125, + 63, + 237, + 82, + 128, + 227, + 235, + 48 + ] + }, + { + "key": [ + 204, + 144, + 194, + 243, + 127, + 151, + 15, + 151, + 172, + 151, + 227, + 227, + 184, + 142, + 138, + 227 + ], + "nonce": [ + 103, + 188, + 192, + 143, + 34, + 63, + 18, + 16, + 126, + 77, + 145, + 34 + ], + "aad": [ + 6, + 90, + 205, + 193, + 146, + 51, + 175, + 75, + 231, + 192, + 103, + 116, + 74, + 171, + 171, + 2, + 76, + 103, + 124, + 94 + ], + "plaintext": [ + 176, + 254, + 13, + 205, + 205, + 82, + 96, + 23, + 245, + 81, + 218, + 31, + 115, + 239, + 159, + 225 + ], + "ciphertext": [ + 80, + 28, + 218, + 44, + 149, + 79, + 131, + 14, + 137, + 34, + 195, + 215, + 64, + 91, + 94, + 225 + ], + "tag": [ + 157, + 238, + 229, + 208, + 228, + 119, + 138, + 159, + 119, + 3, + 103, + 241, + 156, + 116, + 218, + 239 + ] + }, + { + "key": [ + 137, + 133, + 13, + 211, + 152, + 225, + 241, + 226, + 132, + 67, + 163, + 61, + 64, + 22, + 38, + 100 + ], + "nonce": [ + 228, + 98, + 197, + 132, + 130, + 254, + 130, + 100, + 174, + 235, + 114, + 49 + ], + "aad": [ + 215, + 78, + 153, + 209, + 189, + 170, + 113, + 40, + 100, + 238, + 196, + 34, + 172, + 80, + 123, + 221, + 190, + 43, + 13, + 70, + 51, + 205, + 61, + 255, + 41, + 206, + 80, + 89, + 180, + 159, + 232, + 104, + 82, + 108, + 89, + 162, + 163, + 166, + 4, + 69, + 123, + 194, + 175, + 234, + 134, + 110, + 118, + 6 + ], + "plaintext": [ + 40, + 5, + 205, + 239, + 179, + 239, + 108, + 195, + 92, + 209, + 241, + 105, + 249, + 141, + 168, + 26 + ], + "ciphertext": [ + 186, + 128, + 226, + 68, + 183, + 252, + 144, + 37, + 205, + 3, + 29, + 15, + 99, + 103, + 126, + 6 + ], + "tag": [ + 216, + 74, + 140, + 62, + 172, + 87, + 209, + 187, + 14, + 137, + 10, + 143, + 70, + 29, + 16, + 101 + ] + }, + { + "key": [ + 205, + 184, + 80, + 218, + 148, + 211, + 181, + 101, + 99, + 137, + 124, + 89, + 97, + 239, + 58, + 216 + ], + "nonce": [ + 132, + 21, + 135, + 183, + 23, + 79, + 179, + 143, + 183, + 179, + 98, + 110 + ], + "aad": [ + 222, + 51, + 230, + 210, + 12, + 20, + 121, + 100, + 132, + 41, + 61, + 255, + 72, + 202, + 255, + 199, + 132, + 54, + 127, + 75, + 215, + 185, + 87, + 81, + 46, + 192, + 38, + 192, + 171, + 196, + 163, + 146, + 23, + 175, + 13, + 179, + 91, + 225, + 84, + 196, + 88, + 51, + 185, + 122, + 11, + 100, + 84, + 223 + ], + "plaintext": [ + 193, + 104, + 55, + 203, + 72, + 108, + 4, + 189, + 48, + 220, + 174, + 75, + 205, + 11, + 192, + 152 + ], + "ciphertext": [ + 244, + 26, + 155, + 169, + 255, + 41, + 110, + 189, + 190, + 63, + 221, + 139, + 28, + 39, + 220, + 219 + ], + "tag": [ + 80, + 108, + 194, + 19, + 108, + 21, + 35, + 139, + 15, + 36, + 246, + 27, + 82, + 15, + 181, + 230 + ] + }, + { + "key": [ + 69, + 85, + 23, + 16, + 70, + 74, + 158, + 161, + 5, + 163, + 14, + 5, + 97, + 103, + 207, + 176 + ], + "nonce": [ + 87, + 39, + 104, + 140, + 158, + 116, + 188, + 210, + 60, + 20, + 163, + 69 + ], + "aad": [ + 62, + 235, + 205, + 197, + 197, + 233, + 151, + 11, + 63, + 202, + 148, + 189, + 13, + 40, + 234, + 215, + 13, + 31, + 54, + 169, + 79, + 39, + 120, + 4, + 114, + 188, + 60, + 201, + 255, + 57, + 221, + 123, + 126, + 58, + 118, + 235, + 206, + 150, + 125, + 106, + 229, + 114, + 74, + 217, + 4, + 220, + 85, + 72 + ], + "plaintext": [ + 106, + 222, + 170, + 161, + 81, + 181, + 140, + 51, + 116, + 113, + 101, + 60, + 153, + 175, + 251, + 220 + ], + "ciphertext": [ + 236, + 24, + 241, + 214, + 117, + 221, + 5, + 107, + 174, + 179, + 116, + 130, + 156, + 228, + 90, + 51 + ], + "tag": [ + 55, + 139, + 220, + 76, + 52, + 117, + 58, + 18, + 132, + 182, + 84, + 175, + 4, + 155, + 133, + 58 + ] + }, + { + "key": [ + 200, + 101, + 14, + 134, + 149, + 57, + 107, + 132, + 163, + 253, + 238, + 168, + 249, + 92, + 130, + 21 + ], + "nonce": [ + 90, + 28, + 38, + 211, + 132, + 137, + 16, + 19, + 125, + 249, + 247, + 108 + ], + "aad": [ + 61, + 172, + 227, + 155, + 114, + 132, + 234, + 39, + 134, + 166, + 188, + 103, + 12, + 237, + 28, + 124, + 192, + 194, + 140, + 74, + 228, + 231, + 73, + 74, + 109, + 131, + 78, + 176, + 146, + 96, + 182, + 136, + 152, + 185, + 20, + 213, + 166, + 176, + 181, + 51, + 78, + 255, + 150, + 105, + 242, + 51, + 174, + 184 + ], + "plaintext": [ + 136, + 174, + 205, + 151, + 67, + 93, + 151, + 226, + 223, + 248, + 118, + 63, + 100, + 10, + 86, + 64 + ], + "ciphertext": [ + 73, + 169, + 57, + 140, + 112, + 168, + 156, + 14, + 67, + 206, + 122, + 123, + 215, + 169, + 12, + 88 + ], + "tag": [ + 133, + 9, + 239, + 95, + 168, + 4, + 106, + 72, + 165, + 240, + 129, + 229, + 33, + 93, + 178, + 235 + ] + }, + { + "key": [ + 118, + 71, + 15, + 249, + 42, + 174, + 238, + 178, + 65, + 114, + 184, + 35, + 252, + 230, + 48, + 177 + ], + "nonce": [ + 199, + 0, + 136, + 233, + 38, + 51, + 104, + 139, + 235, + 227, + 38, + 91 + ], + "aad": [ + 162, + 98, + 252, + 2, + 163, + 208, + 219, + 17, + 52, + 147, + 212, + 23, + 156, + 201, + 236, + 128, + 104, + 37, + 242, + 15, + 88, + 100, + 187, + 16, + 92, + 97, + 22, + 234, + 114, + 240, + 40, + 73, + 80, + 236, + 200, + 160, + 93, + 197, + 72, + 2, + 56, + 83, + 166, + 87, + 182, + 124, + 224, + 30 + ], + "plaintext": [ + 255, + 79, + 116, + 175, + 21, + 28, + 41, + 42, + 11, + 53, + 186, + 112, + 73, + 201, + 165, + 173 + ], + "ciphertext": [ + 36, + 4, + 134, + 142, + 107, + 254, + 229, + 255, + 230, + 236, + 133, + 23, + 133, + 97, + 138, + 171 + ], + "tag": [ + 179, + 56, + 169, + 204, + 241, + 13, + 69, + 223, + 212, + 224, + 204, + 184, + 168, + 123, + 60, + 26 + ] + }, + { + "key": [ + 36, + 123, + 3, + 48, + 170, + 53, + 168, + 168, + 85, + 20, + 47, + 147, + 61, + 24, + 37, + 129 + ], + "nonce": [ + 109, + 247, + 153, + 11, + 96, + 228, + 31, + 31, + 172, + 95, + 40, + 63 + ], + "aad": [ + 12, + 236, + 105, + 214, + 246, + 83, + 43, + 247, + 129, + 245, + 176, + 254, + 112, + 227, + 62, + 28, + 214, + 143, + 139, + 32, + 25, + 170, + 115, + 149, + 27, + 175, + 151, + 139, + 193, + 20, + 27, + 81, + 8, + 58, + 142, + 92, + 120, + 92, + 153, + 75, + 18, + 255, + 236, + 160, + 27, + 108, + 148, + 244 + ], + "plaintext": [ + 250, + 151, + 156, + 32, + 190, + 159, + 127, + 126, + 128, + 47, + 213, + 202, + 85, + 193, + 70, + 24 + ], + "ciphertext": [ + 202, + 75, + 102, + 160, + 150, + 6, + 202, + 174, + 138, + 16, + 12, + 233, + 148, + 218, + 148, + 82 + ], + "tag": [ + 83, + 65, + 136, + 244, + 57, + 185, + 41, + 24, + 61, + 33, + 16, + 157, + 150, + 33, + 69, + 234 + ] + }, + { + "key": [ + 30, + 165, + 205, + 254, + 32, + 97, + 48, + 89, + 107, + 101, + 91, + 198, + 251, + 147, + 95, + 173 + ], + "nonce": [ + 14, + 201, + 48, + 114, + 231, + 38, + 236, + 88, + 53, + 45, + 90, + 144 + ], + "aad": [ + 217, + 218, + 71, + 65, + 253, + 164, + 130, + 30, + 179, + 145, + 162, + 63, + 127, + 107, + 55, + 123, + 237, + 146, + 50, + 96, + 182, + 248, + 200, + 172, + 155, + 188, + 164, + 237, + 239, + 27, + 194, + 164, + 138, + 69, + 200, + 103, + 108, + 181, + 152, + 166, + 104, + 226, + 143, + 225, + 16, + 62, + 250, + 35 + ], + "plaintext": [ + 26, + 192, + 68, + 181, + 248, + 182, + 147, + 250, + 35, + 105, + 134, + 173, + 22, + 33, + 237, + 216 + ], + "ciphertext": [ + 51, + 211, + 135, + 163, + 183, + 58, + 89, + 11, + 253, + 120, + 50, + 13, + 218, + 216, + 193, + 105 + ], + "tag": [ + 239, + 54, + 214, + 192, + 27, + 90, + 84, + 191, + 6, + 186, + 33, + 138, + 162, + 55, + 250, + 84 + ] + }, + { + "key": [ + 213, + 167, + 7, + 210, + 227, + 22, + 63, + 189, + 159, + 186, + 47, + 18, + 232, + 221, + 152, + 12 + ], + "nonce": [ + 74, + 78, + 211, + 211, + 62, + 90, + 29, + 214, + 190, + 253, + 179, + 130 + ], + "aad": [ + 245, + 57, + 46, + 1, + 76, + 190, + 45, + 51, + 205, + 10, + 4, + 151, + 207, + 3, + 152, + 136, + 51, + 56, + 116, + 132, + 145, + 168, + 84, + 57, + 145, + 153, + 15, + 153, + 88, + 228, + 168, + 39, + 225, + 144, + 230, + 245, + 206, + 137, + 186, + 172, + 95, + 59, + 239, + 145, + 220, + 181, + 133, + 139 + ], + "plaintext": [ + 99, + 147, + 49, + 255, + 78, + 250, + 173, + 201, + 62, + 146, + 229, + 141, + 233, + 232, + 134, + 238 + ], + "ciphertext": [ + 201, + 134, + 196, + 200, + 5, + 9, + 42, + 81, + 16, + 49, + 118, + 181, + 101, + 7, + 221, + 149 + ], + "tag": [ + 93, + 164, + 254, + 78, + 40, + 30, + 153, + 93, + 12, + 117, + 88, + 123, + 73, + 69, + 202, + 133 + ] + }, + { + "key": [ + 61, + 44, + 96, + 67, + 152, + 194, + 71, + 227, + 174, + 125, + 144, + 204, + 30, + 17, + 246, + 207 + ], + "nonce": [ + 93, + 250, + 250, + 82, + 203, + 181, + 47, + 87, + 172, + 48, + 67, + 129 + ], + "aad": [ + 83, + 224, + 80, + 181, + 89, + 48, + 135, + 5, + 55, + 106, + 35, + 238, + 43, + 34, + 183, + 100, + 47, + 6, + 171, + 119, + 160, + 2, + 89, + 191, + 123, + 242, + 140, + 246, + 102, + 89, + 18, + 175, + 75, + 137, + 1, + 248, + 175, + 118, + 233, + 130, + 168, + 188, + 186, + 254, + 94, + 161, + 170, + 246 + ], + "plaintext": [ + 156, + 18, + 203, + 115, + 144, + 38, + 8, + 231, + 178, + 234, + 48, + 218, + 115, + 151, + 182, + 106 + ], + "ciphertext": [ + 127, + 230, + 181, + 168, + 129, + 200, + 166, + 184, + 227, + 226, + 159, + 26, + 56, + 25, + 56, + 59 + ], + "tag": [ + 197, + 40, + 253, + 223, + 129, + 102, + 165, + 192, + 236, + 63, + 2, + 149, + 178, + 195, + 215, + 166 + ] + }, + { + "key": [ + 163, + 53, + 240, + 87, + 124, + 135, + 110, + 97, + 217, + 69, + 34, + 213, + 38, + 21, + 159, + 87 + ], + "nonce": [ + 110, + 168, + 90, + 116, + 81, + 63, + 102, + 74, + 144, + 127, + 239, + 128 + ], + "aad": [ + 3, + 138, + 242, + 112, + 174, + 206, + 150, + 135, + 227, + 76, + 85, + 236, + 48, + 73, + 78, + 159, + 114, + 182, + 169, + 10, + 196, + 50, + 128, + 169, + 184, + 233, + 88, + 53, + 61, + 140, + 2, + 168, + 62, + 209, + 99, + 198, + 146, + 75, + 114, + 1, + 117, + 150, + 21, + 119, + 156, + 213, + 102, + 30 + ], + "plaintext": [ + 219, + 56, + 207, + 59, + 177, + 72, + 37, + 166, + 193, + 26, + 201, + 120, + 251, + 81, + 102, + 71 + ], + "ciphertext": [ + 126, + 129, + 223, + 139, + 240, + 182, + 113, + 232, + 154, + 99, + 157, + 100, + 50, + 212, + 73, + 82 + ], + "tag": [ + 33, + 128, + 230, + 200, + 254, + 143, + 187, + 51, + 148, + 249, + 223, + 220, + 28, + 67, + 157, + 128 + ] + }, + { + "key": [ + 175, + 179, + 171, + 81, + 207, + 5, + 224, + 207, + 162, + 204, + 194, + 195, + 200, + 244, + 182, + 127 + ], + "nonce": [ + 38, + 165, + 209, + 102, + 127, + 234, + 224, + 98, + 193, + 70, + 99, + 188 + ], + "aad": [ + 19, + 11, + 21, + 189, + 231, + 151, + 73, + 208, + 87, + 123, + 255, + 108, + 152, + 171, + 80, + 240, + 53, + 171, + 174, + 4, + 27, + 13, + 95, + 102, + 109, + 178, + 124, + 38, + 44, + 14, + 210, + 168, + 1, + 194, + 79, + 239, + 252, + 254, + 36, + 140, + 243, + 175, + 90, + 252, + 182, + 176, + 221, + 26 + ], + "plaintext": [ + 38, + 130, + 27, + 47, + 226, + 28, + 38, + 210, + 8, + 67, + 175, + 38, + 111, + 206, + 31, + 22 + ], + "ciphertext": [ + 197, + 49, + 122, + 214, + 149, + 96, + 97, + 36, + 102, + 36, + 83, + 219, + 251, + 150, + 162, + 109 + ], + "tag": [ + 42, + 206, + 47, + 167, + 93, + 170, + 49, + 254, + 79, + 32, + 32, + 206, + 169, + 231, + 30, + 198 + ] + }, + { + "key": [ + 11, + 77, + 3, + 59, + 240, + 24, + 43, + 176, + 111, + 139, + 151, + 20, + 213, + 37, + 238, + 116 + ], + "nonce": [ + 240, + 128, + 125, + 204, + 163, + 85, + 170, + 51, + 159, + 235, + 173, + 162 + ], + "aad": [ + 156, + 179, + 115, + 168, + 183, + 204, + 97, + 235, + 56, + 45, + 254, + 30, + 161, + 125, + 120, + 135, + 126, + 147, + 102, + 32, + 124, + 58, + 81, + 97, + 161, + 243, + 75, + 117, + 172, + 80, + 61, + 194, + 14, + 74, + 249, + 217, + 150, + 43, + 125, + 79, + 176, + 243, + 154, + 201, + 102, + 108, + 102, + 12 + ], + "plaintext": [ + 124, + 144, + 112, + 157, + 110, + 163, + 229, + 134, + 187, + 241, + 25, + 19, + 187, + 43, + 82, + 97 + ], + "ciphertext": [ + 191, + 221, + 224, + 110, + 49, + 18, + 64, + 52, + 143, + 4, + 39, + 117, + 4, + 253, + 117, + 251 + ], + "tag": [ + 29, + 197, + 137, + 140, + 73, + 226, + 218, + 180, + 174, + 26, + 89, + 149, + 71, + 167, + 106, + 177 + ] + }, + { + "key": [ + 211, + 43, + 124, + 60, + 179, + 39, + 120, + 13, + 20, + 34, + 17, + 108, + 64, + 71, + 10, + 176 + ], + "nonce": [ + 252, + 199, + 149, + 115, + 5, + 16, + 17, + 104, + 94, + 224, + 217, + 225 + ], + "aad": [ + 205, + 170, + 233, + 136, + 216, + 191, + 1, + 226, + 74, + 75, + 175, + 72, + 152, + 147, + 238, + 50, + 155, + 125, + 13, + 207, + 222, + 246, + 132, + 254, + 62, + 56, + 43, + 32, + 12, + 189, + 90, + 126, + 163, + 228, + 107, + 226, + 129, + 176, + 198, + 204, + 0, + 65, + 125, + 103, + 244, + 211, + 219, + 2 + ], + "plaintext": [ + 240, + 21, + 244, + 171, + 59, + 193, + 89, + 219, + 156, + 246, + 180, + 187, + 103, + 80, + 219, + 70 + ], + "ciphertext": [ + 72, + 190, + 194, + 16, + 246, + 105, + 66, + 248, + 119, + 153, + 62, + 148, + 134, + 166, + 120, + 231 + ], + "tag": [ + 228, + 163, + 130, + 23, + 9, + 98, + 108, + 195, + 0, + 108, + 128, + 90, + 117, + 240, + 103, + 204 + ] + }, + { + "key": [ + 8, + 106, + 12, + 221, + 141, + 82, + 10, + 138, + 105, + 93, + 23, + 232, + 105, + 224, + 62, + 252 + ], + "nonce": [ + 240, + 164, + 99, + 192, + 209, + 226, + 134, + 51, + 218, + 152, + 177, + 226 + ], + "aad": [ + 170, + 126, + 186, + 198, + 31, + 126, + 11, + 157, + 160, + 217, + 65, + 232, + 1, + 115, + 10, + 57, + 59, + 39, + 40, + 71, + 109, + 253, + 6, + 94, + 47, + 110, + 244, + 179, + 67, + 188, + 43, + 166, + 225, + 124, + 89, + 162, + 229, + 56, + 21, + 151, + 148, + 138, + 115, + 255, + 37, + 73, + 63, + 142 + ], + "plaintext": [ + 173, + 111, + 188, + 247, + 20, + 171, + 137, + 52, + 85, + 237, + 219, + 60, + 95, + 180, + 6, + 220 + ], + "ciphertext": [ + 240, + 177, + 163, + 104, + 184, + 50, + 237, + 53, + 213, + 76, + 128, + 6, + 122, + 6, + 162, + 174 + ], + "tag": [ + 227, + 200, + 9, + 16, + 219, + 156, + 225, + 243, + 173, + 37, + 25, + 254, + 30, + 226, + 223, + 215 + ] + }, + { + "key": [ + 228, + 126, + 30, + 58, + 149, + 98, + 116, + 24, + 237, + 101, + 148, + 82, + 163, + 201, + 45, + 69 + ], + "nonce": [ + 120, + 173, + 207, + 63, + 115, + 45, + 211, + 120, + 124, + 181, + 73, + 11 + ], + "aad": [ + 65, + 145, + 58, + 108, + 92, + 77, + 221, + 174, + 6, + 243, + 192, + 246, + 142, + 142, + 206, + 19, + 156, + 169, + 2, + 254, + 52, + 10, + 130, + 14, + 124, + 64, + 216, + 149, + 179, + 94, + 143, + 76, + 186, + 120, + 9, + 199, + 238, + 208, + 178, + 183, + 173, + 69, + 198, + 209, + 82, + 236, + 48, + 83 + ], + "plaintext": [ + 128, + 30, + 252, + 171, + 30, + 50, + 154, + 83, + 106, + 123, + 80, + 108, + 74, + 117, + 9, + 236 + ], + "ciphertext": [ + 103, + 81, + 164, + 165, + 224, + 204, + 60, + 15, + 70, + 203, + 85, + 64, + 147, + 126, + 253, + 232 + ], + "tag": [ + 123, + 7, + 210, + 26, + 76, + 186, + 222, + 237, + 202, + 220, + 232, + 23, + 217, + 171, + 129, + 190 + ] + }, + { + "key": [ + 189, + 124, + 92, + 99, + 183, + 84, + 43, + 86, + 160, + 14, + 190, + 113, + 51, + 106, + 21, + 136 + ], + "nonce": [ + 135, + 114, + 31, + 35, + 186, + 156, + 60, + 142, + 165, + 87, + 26, + 188 + ], + "aad": [ + 166, + 236, + 128, + 117, + 160, + 211, + 55, + 14, + 183, + 89, + 137, + 24, + 243, + 185, + 62, + 72, + 68, + 71, + 81, + 98, + 73, + 151, + 184, + 153, + 168, + 127, + 166, + 169, + 147, + 159, + 132, + 78, + 0, + 138, + 168, + 183, + 14, + 159, + 76, + 59, + 26, + 25, + 211, + 40, + 107, + 245, + 67, + 231, + 18, + 123, + 254, + 203, + 161, + 173, + 23, + 165, + 236, + 83, + 252, + 204, + 38, + 250, + 236, + 172, + 196, + 199, + 83, + 105, + 73, + 142, + 170, + 125, + 112, + 106, + 239, + 99, + 77, + 0, + 9, + 39, + 155, + 17, + 228, + 186, + 108, + 153, + 62, + 94, + 158, + 217 + ], + "plaintext": [ + 222, + 21, + 221, + 187, + 30, + 32, + 33, + 97, + 232, + 167, + 154, + 246, + 165, + 90, + 198, + 243 + ], + "ciphertext": [ + 65, + 235, + 40, + 192, + 254, + 228, + 215, + 98, + 222, + 151, + 35, + 97, + 200, + 99, + 188, + 128 + ], + "tag": [ + 156, + 181, + 103, + 34, + 13, + 11, + 37, + 46, + 185, + 123, + 255, + 70, + 228, + 176, + 15, + 248 + ] + }, + { + "key": [ + 17, + 244, + 117, + 81, + 65, + 97, + 84, + 0, + 107, + 248, + 158, + 117, + 148, + 234, + 32, + 130 + ], + "nonce": [ + 213, + 70, + 252, + 211, + 255, + 42, + 106, + 23, + 70, + 30, + 158, + 148 + ], + "aad": [ + 73, + 239, + 220, + 228, + 142, + 130, + 30, + 177, + 78, + 202, + 95, + 29, + 214, + 97, + 248, + 182, + 185, + 165, + 166, + 145, + 123, + 8, + 236, + 148, + 134, + 194, + 145, + 36, + 239, + 30, + 122, + 154, + 242, + 33, + 116, + 148, + 238, + 202, + 211, + 216, + 238, + 249, + 252, + 34, + 210, + 156, + 225, + 141, + 146, + 0, + 109, + 225, + 88, + 140, + 59, + 6, + 248, + 219, + 159, + 232, + 9, + 190, + 222, + 64, + 144, + 140, + 239, + 79, + 70, + 210, + 196, + 182, + 249, + 47, + 245, + 168, + 48, + 67, + 98, + 116, + 145, + 67, + 218, + 178, + 102, + 222, + 69, + 191, + 91, + 74 + ], + "plaintext": [ + 211, + 120, + 58, + 61, + 122, + 30, + 9, + 31, + 156, + 182, + 71, + 191, + 69, + 96, + 68, + 87 + ], + "ciphertext": [ + 233, + 121, + 136, + 166, + 100, + 91, + 147, + 163, + 46, + 130, + 150, + 187, + 29, + 188, + 184, + 249 + ], + "tag": [ + 57, + 147, + 69, + 249, + 116, + 168, + 42, + 42, + 117, + 0, + 124, + 132, + 170, + 8, + 220, + 26 + ] + }, + { + "key": [ + 7, + 54, + 161, + 240, + 116, + 145, + 157, + 254, + 35, + 191, + 42, + 130, + 142, + 172, + 43, + 38 + ], + "nonce": [ + 91, + 33, + 5, + 22, + 107, + 203, + 21, + 239, + 192, + 127, + 28, + 3 + ], + "aad": [ + 243, + 49, + 166, + 246, + 211, + 29, + 230, + 159, + 17, + 107, + 39, + 252, + 215, + 249, + 20, + 170, + 11, + 44, + 58, + 9, + 73, + 3, + 96, + 231, + 134, + 52, + 23, + 162, + 52, + 96, + 48, + 204, + 153, + 182, + 186, + 56, + 158, + 101, + 224, + 241, + 15, + 224, + 129, + 93, + 56, + 62, + 111, + 152, + 221, + 139, + 185, + 125, + 41, + 144, + 133, + 96, + 206, + 152, + 228, + 191, + 23, + 126, + 66, + 225, + 74, + 113, + 55, + 207, + 211, + 11, + 125, + 203, + 77, + 134, + 85, + 179, + 192, + 53, + 20, + 233, + 90, + 223, + 105, + 134, + 69, + 88, + 68, + 117, + 134, + 90 + ], + "plaintext": [ + 64, + 43, + 91, + 69, + 219, + 190, + 247, + 241, + 217, + 85, + 66, + 62, + 149, + 205, + 164, + 4 + ], + "ciphertext": [ + 110, + 158, + 121, + 226, + 159, + 48, + 133, + 24, + 62, + 10, + 122, + 199, + 246, + 186, + 29, + 103 + ], + "tag": [ + 132, + 67, + 78, + 12, + 130, + 184, + 88, + 236, + 39, + 230, + 28, + 84, + 236, + 246, + 205, + 148 + ] + }, + { + "key": [ + 163, + 146, + 157, + 117, + 63, + 228, + 90, + 111, + 50, + 106, + 133, + 187, + 159, + 30, + 119, + 127 + ], + "nonce": [ + 174, + 216, + 95, + 137, + 132, + 79, + 6, + 17, + 19, + 0, + 77, + 44 + ], + "aad": [ + 236, + 239, + 114, + 167, + 174, + 158, + 107, + 209, + 94, + 99, + 200, + 233, + 251, + 42, + 58, + 124, + 83, + 235, + 154, + 136, + 188, + 5, + 41, + 111, + 246, + 242, + 85, + 68, + 246, + 129, + 255, + 245, + 40, + 154, + 9, + 157, + 56, + 171, + 182, + 131, + 22, + 238, + 216, + 33, + 94, + 173, + 156, + 160, + 70, + 32, + 101, + 190, + 231, + 159, + 219, + 99, + 180, + 64, + 83, + 132, + 5, + 63, + 220, + 104, + 254, + 65, + 36, + 168, + 131, + 245, + 10, + 43, + 75, + 196, + 223, + 110, + 41, + 56, + 60, + 44, + 238, + 164, + 36, + 228, + 172, + 83, + 155, + 38, + 201, + 206 + ], + "plaintext": [ + 240, + 36, + 231, + 150, + 244, + 73, + 113, + 43, + 112, + 213, + 199, + 254, + 91, + 229, + 254, + 20 + ], + "ciphertext": [ + 52, + 158, + 119, + 10, + 127, + 125, + 194, + 251, + 65, + 250, + 8, + 155, + 247, + 35, + 246, + 182 + ], + "tag": [ + 38, + 241, + 43, + 200, + 119, + 125, + 114, + 79, + 229, + 154, + 212, + 254, + 43, + 151, + 87, + 244 + ] + }, + { + "key": [ + 133, + 171, + 214, + 199, + 185, + 3, + 20, + 178, + 155, + 189, + 41, + 63, + 241, + 19, + 99, + 126 + ], + "nonce": [ + 244, + 143, + 78, + 210, + 235, + 123, + 122, + 174, + 176, + 23, + 238, + 114 + ], + "aad": [ + 43, + 130, + 93, + 71, + 126, + 185, + 110, + 13, + 141, + 120, + 126, + 228, + 242, + 132, + 236, + 165, + 103, + 251, + 82, + 20, + 180, + 126, + 38, + 112, + 83, + 137, + 207, + 159, + 206, + 75, + 141, + 188, + 73, + 161, + 82, + 223, + 94, + 74, + 204, + 176, + 173, + 170, + 25, + 179, + 124, + 144, + 254, + 125, + 110, + 180, + 86, + 160, + 103, + 241, + 194, + 182, + 59, + 97, + 246, + 213, + 150, + 32, + 159, + 126, + 233, + 108, + 133, + 170, + 72, + 241, + 135, + 14, + 147, + 56, + 116, + 62, + 223, + 241, + 216, + 255, + 182, + 29, + 189, + 171, + 136, + 182, + 117, + 95, + 161, + 53 + ], + "plaintext": [ + 84, + 44, + 111, + 167, + 231, + 205, + 175, + 33, + 230, + 246, + 179, + 69, + 23, + 242, + 106, + 181 + ], + "ciphertext": [ + 131, + 116, + 249, + 111, + 3, + 120, + 7, + 36, + 168, + 232, + 209, + 241, + 23, + 104, + 212, + 79 + ], + "tag": [ + 180, + 27, + 83, + 196, + 106, + 231, + 110, + 255, + 80, + 92, + 254, + 228, + 122, + 141, + 170, + 163 + ] + }, + { + "key": [ + 10, + 47, + 41, + 113, + 15, + 235, + 124, + 134, + 23, + 90, + 55, + 196, + 30, + 50, + 250, + 221 + ], + "nonce": [ + 177, + 144, + 253, + 185, + 16, + 97, + 160, + 142, + 248, + 33, + 0, + 184 + ], + "aad": [ + 10, + 244, + 213, + 193, + 236, + 81, + 122, + 31, + 193, + 4, + 174, + 167, + 213, + 19, + 181, + 145, + 182, + 3, + 99, + 79, + 197, + 88, + 0, + 126, + 6, + 214, + 205, + 34, + 153, + 116, + 7, + 235, + 130, + 129, + 167, + 66, + 174, + 246, + 232, + 139, + 160, + 143, + 16, + 198, + 75, + 66, + 49, + 33, + 216, + 152, + 188, + 208, + 76, + 31, + 29, + 108, + 124, + 18, + 214, + 115, + 170, + 26, + 187, + 0, + 74, + 133, + 37, + 241, + 215, + 171, + 194, + 60, + 135, + 36, + 136, + 81, + 121, + 226, + 146, + 192, + 86, + 90, + 57, + 217, + 245, + 198, + 210, + 54, + 158, + 55 + ], + "plaintext": [ + 223, + 182, + 40, + 79, + 253, + 108, + 193, + 149, + 237, + 117, + 219, + 12, + 159, + 175, + 85, + 89 + ], + "ciphertext": [ + 251, + 108, + 182, + 82, + 123, + 146, + 220, + 46, + 246, + 162, + 39, + 232, + 6, + 120, + 121, + 170 + ], + "tag": [ + 224, + 16, + 55, + 246, + 233, + 214, + 44, + 24, + 177, + 99, + 167, + 20, + 248, + 90, + 146, + 204 + ] + }, + { + "key": [ + 71, + 13, + 87, + 113, + 55, + 197, + 1, + 75, + 120, + 19, + 125, + 198, + 178, + 78, + 250, + 109 + ], + "nonce": [ + 74, + 250, + 127, + 87, + 102, + 248, + 52, + 90, + 27, + 18, + 4, + 43 + ], + "aad": [ + 207, + 221, + 93, + 66, + 224, + 208, + 18, + 122, + 28, + 13, + 60, + 75, + 173, + 48, + 46, + 242, + 58, + 182, + 61, + 135, + 159, + 173, + 113, + 16, + 159, + 71, + 146, + 229, + 178, + 17, + 86, + 218, + 253, + 206, + 192, + 34, + 252, + 50, + 48, + 40, + 169, + 251, + 202, + 254, + 12, + 54, + 6, + 237, + 97, + 181, + 130, + 191, + 160, + 11, + 166, + 229, + 201, + 161, + 177, + 59, + 151, + 109, + 103, + 193, + 76, + 121, + 144, + 90, + 118, + 147, + 153, + 217, + 103, + 176, + 221, + 69, + 240, + 231, + 73, + 103, + 182, + 125, + 123, + 182, + 125, + 148, + 102, + 97, + 143, + 161 + ], + "plaintext": [ + 71, + 69, + 203, + 154, + 62, + 227, + 167, + 106, + 225, + 102, + 218, + 213, + 161, + 182, + 43, + 28 + ], + "ciphertext": [ + 202, + 88, + 206, + 216, + 99, + 105, + 107, + 248, + 10, + 224, + 25, + 29, + 225, + 37, + 35, + 51 + ], + "tag": [ + 36, + 109, + 69, + 31, + 170, + 184, + 133, + 17, + 70, + 126, + 56, + 182, + 12, + 91, + 70, + 199 + ] + }, + { + "key": [ + 92, + 249, + 207, + 164, + 211, + 103, + 117, + 47, + 19, + 84, + 3, + 126, + 19, + 43, + 201, + 72 + ], + "nonce": [ + 19, + 230, + 162, + 134, + 166, + 199, + 177, + 137, + 151, + 77, + 126, + 163 + ], + "aad": [ + 101, + 218, + 77, + 189, + 108, + 239, + 127, + 200, + 160, + 154, + 118, + 106, + 111, + 91, + 71, + 78, + 151, + 17, + 162, + 212, + 15, + 175, + 132, + 28, + 70, + 122, + 136, + 56, + 229, + 200, + 202, + 218, + 63, + 28, + 202, + 116, + 237, + 59, + 76, + 221, + 166, + 213, + 211, + 52, + 201, + 23, + 99, + 231, + 152, + 185, + 199, + 137, + 27, + 41, + 29, + 191, + 70, + 216, + 157, + 220, + 114, + 141, + 114, + 249, + 60, + 149, + 224, + 129, + 188, + 52, + 4, + 72, + 81, + 154, + 236, + 204, + 109, + 16, + 91, + 241, + 105, + 107, + 127, + 249, + 192, + 183, + 192, + 6, + 68, + 76 + ], + "plaintext": [ + 199, + 239, + 51, + 231, + 171, + 200, + 242, + 152, + 178, + 242, + 36, + 207, + 82, + 24, + 102, + 29 + ], + "ciphertext": [ + 173, + 136, + 244, + 231, + 185, + 128, + 190, + 5, + 179, + 223, + 15, + 192, + 90, + 73, + 209, + 235 + ], + "tag": [ + 10, + 209, + 83, + 120, + 241, + 143, + 67, + 56, + 150, + 110, + 142, + 23, + 149, + 29, + 141, + 173 + ] + }, + { + "key": [ + 209, + 218, + 253, + 158, + 7, + 171, + 15, + 144, + 58, + 155, + 0, + 214, + 227, + 83, + 214, + 127 + ], + "nonce": [ + 138, + 150, + 160, + 254, + 136, + 240, + 199, + 227, + 7, + 124, + 56, + 244 + ], + "aad": [ + 211, + 225, + 236, + 208, + 111, + 121, + 230, + 131, + 151, + 103, + 217, + 87, + 196, + 215, + 21, + 180, + 34, + 143, + 76, + 188, + 167, + 175, + 164, + 41, + 216, + 96, + 197, + 219, + 42, + 107, + 244, + 163, + 173, + 226, + 208, + 11, + 145, + 135, + 95, + 237, + 191, + 155, + 9, + 233, + 238, + 94, + 105, + 24, + 47, + 50, + 111, + 179, + 111, + 204, + 53, + 71, + 94, + 251, + 50, + 229, + 234, + 218, + 58, + 111, + 166, + 4, + 108, + 141, + 12, + 14, + 233, + 51, + 176, + 231, + 243, + 124, + 135, + 179, + 235, + 139, + 156, + 12, + 43, + 69, + 127, + 134, + 149, + 210, + 88, + 117 + ], + "plaintext": [ + 187, + 228, + 204, + 189, + 38, + 82, + 45, + 53, + 202, + 13, + 72, + 51, + 65, + 56, + 94, + 43 + ], + "ciphertext": [ + 157, + 1, + 108, + 217, + 73, + 51, + 192, + 124, + 16, + 185, + 42, + 244, + 14, + 175, + 172, + 125 + ], + "tag": [ + 2, + 46, + 45, + 213, + 138, + 200, + 98, + 150, + 46, + 127, + 160, + 83, + 107, + 173, + 135, + 203 + ] + }, + { + "key": [ + 218, + 82, + 54, + 178, + 84, + 238, + 47, + 245, + 215, + 231, + 61, + 122, + 9, + 87, + 65, + 119 + ], + "nonce": [ + 210, + 217, + 31, + 92, + 48, + 34, + 18, + 85, + 127, + 214, + 43, + 206 + ], + "aad": [ + 157, + 223, + 160, + 82, + 144, + 226, + 40, + 229, + 236, + 235, + 126, + 150, + 222, + 58, + 9, + 122, + 250, + 169, + 109, + 141, + 62, + 13, + 95, + 252, + 14, + 1, + 22, + 244, + 56, + 20, + 245, + 176, + 148, + 121, + 25, + 38, + 124, + 45, + 191, + 14, + 95, + 82, + 169, + 114, + 150, + 231, + 130, + 111, + 40, + 145, + 221, + 74, + 4, + 60, + 132, + 80, + 70, + 201, + 171, + 154, + 232, + 50, + 115, + 70, + 199, + 105, + 90, + 114, + 135, + 91, + 144, + 98, + 221, + 85, + 120, + 190, + 137, + 133, + 237, + 249, + 250, + 164, + 145, + 121, + 129, + 170, + 204, + 111, + 17, + 47 + ], + "plaintext": [ + 58, + 170, + 42, + 123, + 38, + 5, + 104, + 108, + 52, + 68, + 187, + 22, + 223, + 140, + 87, + 165 + ], + "ciphertext": [ + 32, + 42, + 142, + 103, + 215, + 242, + 47, + 248, + 55, + 87, + 252, + 158, + 249, + 178, + 10, + 15 + ], + "tag": [ + 165, + 91, + 171, + 36, + 42, + 78, + 190, + 115, + 181, + 44, + 199, + 32, + 47, + 92, + 221, + 87 + ] + }, + { + "key": [ + 195, + 229, + 119, + 218, + 42, + 43, + 127, + 221, + 5, + 201, + 157, + 198, + 252, + 129, + 204, + 221 + ], + "nonce": [ + 223, + 167, + 71, + 176, + 143, + 83, + 105, + 21, + 52, + 87, + 102, + 240 + ], + "aad": [ + 135, + 42, + 109, + 14, + 58, + 10, + 59, + 50, + 244, + 201, + 42, + 78, + 91, + 175, + 126, + 251, + 114, + 112, + 169, + 171, + 156, + 252, + 211, + 193, + 23, + 58, + 47, + 203, + 44, + 21, + 90, + 146, + 63, + 157, + 139, + 142, + 53, + 169, + 101, + 177, + 29, + 21, + 226, + 224, + 204, + 89, + 30, + 149, + 61, + 168, + 28, + 23, + 43, + 136, + 130, + 52, + 76, + 255, + 123, + 64, + 238, + 170, + 48, + 212, + 121, + 57, + 0, + 221, + 133, + 203, + 101, + 251, + 234, + 233, + 209, + 211, + 178, + 166, + 44, + 102, + 203, + 147, + 45, + 172, + 30, + 104, + 6, + 171, + 97, + 80 + ], + "plaintext": [ + 184, + 99, + 18, + 4, + 38, + 212, + 203, + 213, + 199, + 49, + 36, + 199, + 176, + 52, + 47, + 167 + ], + "ciphertext": [ + 67, + 218, + 136, + 128, + 71, + 203, + 28, + 252, + 125, + 212, + 35, + 41, + 49, + 12, + 130, + 52 + ], + "tag": [ + 248, + 38, + 118, + 53, + 170, + 123, + 81, + 184, + 156, + 128, + 250, + 151, + 152, + 97, + 235, + 63 + ] + }, + { + "key": [ + 105, + 225, + 192, + 145, + 124, + 168, + 212, + 154, + 166, + 159, + 56, + 207, + 156, + 102, + 235, + 77 + ], + "nonce": [ + 12, + 85, + 103, + 35, + 54, + 210, + 25, + 230, + 76, + 96, + 225, + 93 + ], + "aad": [ + 193, + 180, + 35, + 242, + 125, + 121, + 78, + 148, + 123, + 197, + 106, + 172, + 227, + 153, + 80, + 101, + 39, + 146, + 33, + 245, + 184, + 190, + 246, + 86, + 139, + 91, + 40, + 130, + 32, + 155, + 240, + 221, + 119, + 118, + 233, + 174, + 110, + 177, + 161, + 237, + 160, + 183, + 104, + 174, + 170, + 237, + 158, + 56, + 132, + 204, + 57, + 104, + 182, + 209, + 121, + 233, + 229, + 171, + 240, + 141, + 248, + 38, + 28, + 62, + 229, + 79, + 139, + 14, + 175, + 38, + 70, + 203, + 34, + 18, + 136, + 168, + 121, + 197, + 234, + 78, + 145, + 131, + 128, + 93, + 193, + 218, + 138, + 99, + 106, + 88 + ], + "plaintext": [ + 125, + 172, + 62, + 49, + 38, + 157, + 215, + 147, + 153, + 201, + 71, + 152, + 244, + 187, + 198, + 64 + ], + "ciphertext": [ + 55, + 210, + 21, + 161, + 51, + 98, + 191, + 8, + 123, + 203, + 168, + 249, + 89, + 1, + 235, + 5 + ], + "tag": [ + 27, + 62, + 236, + 183, + 174, + 147, + 134, + 219, + 193, + 64, + 158, + 112, + 245, + 130, + 127, + 88 + ] + }, + { + "key": [ + 8, + 129, + 141, + 81, + 101, + 88, + 99, + 17, + 97, + 228, + 158, + 235, + 214, + 33, + 247, + 141 + ], + "nonce": [ + 241, + 248, + 85, + 235, + 138, + 236, + 204, + 157, + 223, + 122, + 168, + 14 + ], + "aad": [ + 104, + 254, + 223, + 106, + 66, + 183, + 128, + 238, + 176, + 17, + 170, + 11, + 36, + 38, + 54, + 102, + 142, + 92, + 137, + 65, + 214, + 4, + 91, + 5, + 201, + 72, + 248, + 44, + 93, + 179, + 151, + 120, + 49, + 67, + 90, + 180, + 4, + 152, + 149, + 182, + 7, + 232, + 84, + 247, + 16, + 227, + 216, + 183, + 162, + 106, + 250, + 162, + 231, + 145, + 48, + 147, + 49, + 62, + 147, + 195, + 225, + 6, + 168, + 53, + 109, + 108, + 68, + 87, + 147, + 152, + 206, + 67, + 65, + 170, + 203, + 59, + 114, + 110, + 127, + 66, + 250, + 183, + 89, + 52, + 146, + 13, + 242, + 48, + 203, + 75 + ], + "plaintext": [ + 26, + 137, + 201, + 201, + 98, + 58, + 38, + 183, + 200, + 6, + 44, + 95, + 106, + 95, + 127, + 152 + ], + "ciphertext": [ + 158, + 18, + 227, + 132, + 47, + 247, + 245, + 194, + 90, + 23, + 28, + 196, + 197, + 163, + 223, + 168 + ], + "tag": [ + 1, + 205, + 73, + 128, + 217, + 45, + 246, + 115, + 155, + 237, + 242, + 34, + 1, + 162, + 204, + 18 + ] + }, + { + "key": [ + 191, + 164, + 161, + 43, + 53, + 118, + 5, + 177, + 30, + 101, + 250, + 146, + 185, + 13, + 34, + 252 + ], + "nonce": [ + 154, + 235, + 114, + 27, + 105, + 141, + 180, + 13, + 201, + 8, + 14, + 35 + ], + "aad": [ + 83, + 188, + 102, + 22, + 72, + 17, + 134, + 110, + 18, + 235, + 205, + 100, + 68, + 124, + 153, + 151, + 119, + 55, + 129, + 25, + 162, + 87, + 254, + 0, + 212, + 91, + 92, + 147, + 146, + 213, + 97, + 143, + 44, + 44, + 120, + 70, + 150, + 245, + 169, + 254, + 168, + 93, + 15, + 140, + 156, + 181, + 67, + 139, + 21, + 179, + 245, + 102, + 29, + 73, + 224, + 176, + 152, + 15, + 246, + 26, + 238, + 224, + 205, + 246, + 80, + 171, + 79, + 168, + 43, + 203, + 13, + 3, + 144, + 249, + 157, + 175, + 2, + 216, + 86, + 27, + 245, + 188, + 165, + 98, + 126, + 59, + 25, + 73, + 81, + 174 + ], + "plaintext": [ + 147, + 131, + 53, + 138, + 64, + 101, + 243, + 227, + 101, + 146, + 79, + 127, + 166, + 100, + 1, + 43 + ], + "ciphertext": [ + 223, + 70, + 157, + 152, + 103, + 68, + 195, + 50, + 68, + 104, + 33, + 132, + 145, + 44, + 221, + 104 + ], + "tag": [ + 140, + 18, + 248, + 51, + 143, + 251, + 120, + 64, + 224, + 133, + 253, + 237, + 170, + 106, + 179, + 204 + ] + }, + { + "key": [ + 225, + 106, + 87, + 200, + 63, + 35, + 12, + 54, + 138, + 15, + 89, + 154, + 126, + 191, + 63, + 94 + ], + "nonce": [ + 38, + 49, + 184, + 17, + 234, + 87, + 203, + 125, + 88, + 250, + 35, + 42 + ], + "aad": [ + 213, + 188, + 16, + 26, + 210, + 111, + 125, + 3, + 153, + 158, + 172, + 18, + 47, + 78, + 6, + 15, + 32, + 164, + 2, + 255, + 138, + 42, + 3, + 36, + 167, + 119, + 84, + 225, + 235, + 139, + 122, + 101, + 247, + 135, + 67, + 172, + 46, + 227, + 75, + 84, + 41, + 236, + 159, + 214, + 18, + 15, + 230, + 209, + 126, + 113, + 247, + 56, + 206, + 191, + 10, + 227, + 154, + 91, + 229, + 164, + 221, + 232, + 83, + 132, + 217, + 140, + 217, + 13, + 33, + 135, + 133, + 176, + 141, + 170, + 102, + 47, + 36, + 24, + 113, + 86, + 17, + 143, + 186, + 152, + 27, + 150, + 145, + 207, + 18, + 248 + ], + "plaintext": [ + 42, + 55, + 227, + 128, + 245, + 117, + 228, + 54, + 81, + 22, + 254, + 137, + 165, + 142, + 232, + 220 + ], + "ciphertext": [ + 146, + 120, + 209, + 234, + 176, + 125, + 199, + 250, + 104, + 116, + 32, + 89, + 217, + 253, + 190, + 96 + ], + "tag": [ + 39, + 164, + 116, + 41, + 79, + 248, + 17, + 219, + 79, + 110, + 12, + 136, + 177, + 168, + 107, + 12 + ] + }, + { + "key": [ + 254, + 155, + 180, + 125, + 235, + 58, + 97, + 228, + 35, + 194, + 35, + 24, + 65, + 207, + 209, + 251 + ], + "nonce": [ + 77, + 50, + 142, + 183, + 118, + 245, + 0, + 162, + 247, + 251, + 71, + 170 + ], + "aad": [], + "plaintext": [ + 241, + 204, + 56, + 24, + 228, + 33, + 135, + 107, + 182, + 184, + 187, + 214, + 201 + ], + "ciphertext": [ + 184, + 140, + 92, + 25, + 119, + 179, + 91, + 81, + 123, + 10, + 234, + 233, + 103 + ], + "tag": [ + 67, + 253, + 71, + 39, + 254, + 92, + 219, + 75, + 91, + 66, + 129, + 141, + 234, + 126, + 248, + 201 + ] + }, + { + "key": [ + 103, + 3, + 223, + 55, + 1, + 167, + 245, + 73, + 17, + 202, + 114, + 226, + 77, + 202, + 4, + 106 + ], + "nonce": [ + 18, + 130, + 58, + 182, + 1, + 195, + 80, + 234, + 75, + 194, + 72, + 140 + ], + "aad": [], + "plaintext": [ + 121, + 60, + 209, + 37, + 176, + 184, + 74, + 4, + 62, + 58, + 198, + 119, + 23 + ], + "ciphertext": [ + 178, + 5, + 28, + 128, + 1, + 79, + 66, + 240, + 135, + 53, + 167, + 176, + 205 + ], + "tag": [ + 56, + 230, + 188, + 210, + 153, + 98, + 229, + 242, + 193, + 54, + 38, + 184, + 90, + 135, + 113, + 1 + ] + }, + { + "key": [ + 91, + 215, + 54, + 47, + 56, + 186, + 253, + 51, + 255, + 64, + 104, + 134, + 14, + 179, + 92, + 39 + ], + "nonce": [ + 96, + 100, + 54, + 129, + 102, + 196, + 134, + 51, + 176, + 144, + 203, + 154 + ], + "aad": [], + "plaintext": [ + 99, + 72, + 82, + 166, + 182, + 133, + 67, + 234, + 216, + 137, + 170, + 25, + 239 + ], + "ciphertext": [ + 58, + 68, + 249, + 17, + 55, + 108, + 55, + 30, + 109, + 89, + 117, + 57, + 211 + ], + "tag": [ + 69, + 43, + 103, + 233, + 211, + 106, + 158, + 197, + 168, + 147, + 39, + 43, + 77, + 47, + 33, + 3 + ] + }, + { + "key": [ + 37, + 145, + 54, + 2, + 40, + 221, + 148, + 90, + 174, + 143, + 186, + 149, + 220, + 39, + 37, + 197 + ], + "nonce": [ + 42, + 218, + 188, + 21, + 193, + 110, + 92, + 89, + 84, + 200, + 171, + 1 + ], + "aad": [], + "plaintext": [ + 197, + 128, + 176, + 81, + 96, + 13, + 217, + 2, + 178, + 115, + 226, + 102, + 119 + ], + "ciphertext": [ + 154, + 198, + 106, + 169, + 61, + 117, + 71, + 188, + 10, + 69, + 186, + 245, + 172 + ], + "tag": [ + 166, + 9, + 65, + 60, + 156, + 19, + 129, + 114, + 135, + 243, + 156, + 252, + 244, + 218, + 46, + 110 + ] + }, + { + "key": [ + 60, + 133, + 246, + 78, + 53, + 149, + 63, + 44, + 173, + 237, + 99, + 249, + 135, + 89, + 38, + 17 + ], + "nonce": [ + 122, + 209, + 60, + 180, + 14, + 33, + 238, + 99, + 50, + 81, + 150, + 143 + ], + "aad": [], + "plaintext": [ + 123, + 221, + 180, + 3, + 124, + 43, + 224, + 15, + 78, + 246, + 248, + 92, + 205 + ], + "ciphertext": [ + 156, + 32, + 48, + 227, + 225, + 158, + 73, + 12, + 48, + 150, + 16, + 216, + 137 + ], + "tag": [ + 176, + 228, + 8, + 10, + 141, + 174, + 84, + 166, + 119, + 15, + 78, + 33, + 213, + 50, + 78, + 144 + ] + }, + { + "key": [ + 123, + 141, + 50, + 56, + 45, + 41, + 192, + 1, + 152, + 241, + 212, + 31, + 198, + 181, + 43, + 140 + ], + "nonce": [ + 189, + 101, + 215, + 40, + 26, + 154, + 106, + 169, + 252, + 38, + 143, + 97 + ], + "aad": [], + "plaintext": [ + 16, + 242, + 125, + 171, + 185, + 201, + 233, + 250, + 203, + 210, + 27, + 19, + 205 + ], + "ciphertext": [ + 112, + 126, + 251, + 213, + 74, + 171, + 190, + 204, + 34, + 238, + 107, + 83, + 4 + ], + "tag": [ + 202, + 53, + 245, + 222, + 168, + 105, + 80, + 134, + 83, + 206, + 85, + 108, + 156, + 5, + 211, + 46 + ] + }, + { + "key": [ + 221, + 149, + 168, + 202, + 37, + 136, + 51, + 83, + 175, + 245, + 196, + 20, + 173, + 154, + 197, + 192 + ], + "nonce": [ + 190, + 46, + 211, + 164, + 211, + 143, + 166, + 92, + 243, + 65, + 229, + 238 + ], + "aad": [], + "plaintext": [ + 91, + 12, + 41, + 200, + 190, + 242, + 25, + 213, + 41, + 50, + 179, + 48, + 65 + ], + "ciphertext": [ + 73, + 24, + 172, + 226, + 89, + 97, + 250, + 224, + 109, + 189, + 137, + 29, + 22 + ], + "tag": [ + 174, + 111, + 6, + 154, + 204, + 250, + 203, + 166, + 26, + 56, + 50, + 61, + 214, + 95, + 76, + 2 + ] + }, + { + "key": [ + 77, + 176, + 25, + 131, + 246, + 173, + 158, + 57, + 56, + 80, + 112, + 184, + 16, + 194, + 108, + 128 + ], + "nonce": [ + 35, + 66, + 220, + 63, + 182, + 96, + 227, + 146, + 85, + 9, + 182, + 237 + ], + "aad": [], + "plaintext": [ + 92, + 239, + 108, + 79, + 5, + 7, + 58, + 227, + 158, + 5, + 53, + 109, + 197 + ], + "ciphertext": [ + 18, + 228, + 31, + 67, + 115, + 241, + 229, + 220, + 252, + 247, + 88, + 226, + 200 + ], + "tag": [ + 54, + 254, + 27, + 137, + 129, + 148, + 111, + 209, + 108, + 241, + 42, + 216, + 15, + 4, + 213, + 158 + ] + }, + { + "key": [ + 141, + 89, + 249, + 49, + 212, + 207, + 138, + 38, + 131, + 226, + 105, + 0, + 142, + 232, + 96, + 98 + ], + "nonce": [ + 122, + 200, + 98, + 160, + 156, + 52, + 8, + 182, + 103, + 232, + 205, + 56 + ], + "aad": [], + "plaintext": [ + 44, + 71, + 65, + 58, + 130, + 86, + 242, + 86, + 119, + 177, + 222, + 142, + 241 + ], + "ciphertext": [ + 40, + 79, + 244, + 223, + 228, + 37, + 95, + 86, + 180, + 165, + 101, + 133, + 167 + ], + "tag": [ + 22, + 192, + 164, + 165, + 130, + 110, + 41, + 29, + 75, + 63, + 126, + 173, + 104, + 146, + 195, + 146 + ] + }, + { + "key": [ + 1, + 198, + 129, + 226, + 207, + 29, + 124, + 132, + 132, + 195, + 129, + 18, + 1, + 55, + 97, + 135 + ], + "nonce": [ + 86, + 168, + 244, + 138, + 49, + 152, + 185, + 119, + 245, + 6, + 77, + 2 + ], + "aad": [], + "plaintext": [ + 55, + 220, + 15, + 87, + 44, + 158, + 81, + 198, + 252, + 24, + 100, + 45, + 127 + ], + "ciphertext": [ + 84, + 146, + 44, + 101, + 2, + 54, + 5, + 193, + 235, + 161, + 70, + 212, + 72 + ], + "tag": [ + 221, + 219, + 246, + 84, + 3, + 14, + 115, + 190, + 13, + 214, + 210, + 107, + 103, + 239, + 208, + 230 + ] + }, + { + "key": [ + 218, + 230, + 207, + 218, + 137, + 121, + 128, + 29, + 147, + 153, + 0, + 103, + 151, + 162, + 54, + 107 + ], + "nonce": [ + 28, + 180, + 29, + 172, + 19, + 255, + 167, + 46, + 114, + 164, + 5, + 208 + ], + "aad": [], + "plaintext": [ + 159, + 67, + 172, + 83, + 212, + 206, + 200, + 13, + 210, + 154, + 144, + 45, + 134 + ], + "ciphertext": [ + 225, + 86, + 165, + 240, + 113, + 16, + 150, + 202, + 221, + 72, + 153, + 55, + 167 + ], + "tag": [ + 223, + 162, + 210, + 163, + 66, + 183, + 138, + 198, + 231, + 39, + 99, + 101, + 242, + 250, + 109, + 192 + ] + }, + { + "key": [ + 81, + 70, + 235, + 227, + 209, + 253, + 241, + 102, + 255, + 164, + 9, + 155, + 99, + 140, + 91, + 100 + ], + "nonce": [ + 16, + 1, + 68, + 73, + 129, + 125, + 136, + 19, + 40, + 194, + 184, + 130 + ], + "aad": [], + "plaintext": [ + 112, + 10, + 246, + 152, + 149, + 39, + 235, + 22, + 255, + 171, + 102, + 52, + 210 + ], + "ciphertext": [ + 138, + 179, + 92, + 40, + 143, + 9, + 8, + 77, + 163, + 192, + 203, + 210, + 64 + ], + "tag": [ + 238, + 200, + 35, + 47, + 41, + 7, + 178, + 225, + 203, + 44, + 148, + 6, + 34, + 83, + 13, + 37 + ] + }, + { + "key": [ + 205, + 112, + 248, + 111, + 192, + 161, + 120, + 7, + 64, + 254, + 254, + 245, + 116, + 46, + 67, + 152 + ], + "nonce": [ + 194, + 171, + 209, + 25, + 242, + 45, + 49, + 11, + 52, + 244, + 28, + 92 + ], + "aad": [], + "plaintext": [ + 57, + 251, + 73, + 122, + 38, + 145, + 38, + 79, + 2, + 252, + 186, + 72, + 135 + ], + "ciphertext": [ + 1, + 51, + 154, + 58, + 145, + 25, + 131, + 111, + 107, + 3, + 138, + 26, + 80 + ], + "tag": [ + 228, + 90, + 10, + 18, + 200, + 78, + 186, + 175, + 24, + 133, + 244, + 87, + 80, + 123, + 154, + 94 + ] + }, + { + "key": [ + 136, + 40, + 69, + 76, + 238, + 253, + 144, + 4, + 227, + 10, + 232, + 160, + 61, + 113, + 249, + 209 + ], + "nonce": [ + 141, + 158, + 60, + 97, + 170, + 104, + 122, + 143, + 43, + 158, + 227, + 10 + ], + "aad": [], + "plaintext": [ + 169, + 75, + 2, + 15, + 71, + 36, + 23, + 138, + 63, + 79, + 145, + 55, + 197 + ], + "ciphertext": [ + 196, + 169, + 79, + 137, + 224, + 51, + 5, + 170, + 65, + 92, + 123, + 53, + 12 + ], + "tag": [ + 26, + 204, + 28, + 117, + 185, + 252, + 130, + 106, + 242, + 233, + 80, + 204, + 123, + 230, + 207, + 100 + ] + }, + { + "key": [ + 71, + 152, + 47, + 19, + 60, + 183, + 35, + 66, + 221, + 100, + 47, + 52, + 117, + 189, + 230, + 52 + ], + "nonce": [ + 131, + 4, + 48, + 74, + 206, + 162, + 222, + 247, + 120, + 242, + 191, + 158 + ], + "aad": [], + "plaintext": [ + 44, + 151, + 165, + 251, + 109, + 248, + 81, + 83, + 165, + 195, + 191, + 65, + 76 + ], + "ciphertext": [ + 55, + 224, + 150, + 41, + 96, + 237, + 207, + 10, + 9, + 168, + 83, + 140, + 172 + ], + "tag": [ + 7, + 69, + 159, + 164, + 56, + 225, + 241, + 89, + 166, + 100, + 154, + 142, + 214, + 249, + 52, + 184 + ] + }, + { + "key": [ + 223, + 239, + 222, + 35, + 198, + 18, + 43, + 240, + 55, + 10, + 181, + 137, + 14, + 128, + 75, + 115 + ], + "nonce": [ + 146, + 214, + 168, + 2, + 153, + 144, + 103, + 15, + 22, + 222, + 121, + 226 + ], + "aad": [ + 162, + 177, + 109, + 120, + 37, + 29, + 230, + 193, + 145, + 206, + 53, + 14, + 92, + 94, + 242, + 66 + ], + "plaintext": [ + 100, + 38, + 10, + 140, + 40, + 125, + 233, + 120, + 233, + 108, + 117, + 33, + 208 + ], + "ciphertext": [ + 191, + 120, + 222, + 148, + 138, + 132, + 124, + 23, + 54, + 73, + 212, + 180, + 208 + ], + "tag": [ + 157, + 163, + 130, + 153, + 104, + 205, + 197, + 7, + 148, + 209, + 195, + 13, + 65, + 205, + 69, + 21 + ] + }, + { + "key": [ + 48, + 22, + 98, + 0, + 21, + 219, + 29, + 133, + 238, + 240, + 155, + 188, + 229, + 10, + 226, + 148 + ], + "nonce": [ + 235, + 72, + 29, + 179, + 165, + 34, + 1, + 23, + 62, + 45, + 74, + 215 + ], + "aad": [ + 250, + 61, + 149, + 184, + 26, + 97, + 150, + 56, + 206, + 163, + 246, + 141, + 251, + 192, + 33, + 51 + ], + "plaintext": [ + 56, + 181, + 124, + 13, + 65, + 81, + 215, + 238, + 87, + 224, + 50, + 130, + 159 + ], + "ciphertext": [ + 119, + 56, + 96, + 26, + 177, + 71, + 72, + 34, + 49, + 100, + 209, + 246, + 157 + ], + "tag": [ + 99, + 202, + 158, + 140, + 39, + 217, + 250, + 131, + 124, + 164, + 160, + 187, + 112, + 57, + 227, + 144 + ] + }, + { + "key": [ + 179, + 186, + 56, + 41, + 9, + 233, + 78, + 245, + 211, + 24, + 238, + 50, + 203, + 84, + 163, + 62 + ], + "nonce": [ + 60, + 241, + 11, + 23, + 0, + 113, + 20, + 134, + 17, + 156, + 253, + 158 + ], + "aad": [ + 209, + 225, + 124, + 1, + 137, + 176, + 69, + 97, + 105, + 155, + 210, + 247, + 145, + 214, + 148, + 145 + ], + "plaintext": [ + 74, + 144, + 173, + 63, + 151, + 201, + 199, + 232, + 46, + 252, + 187, + 49, + 139 + ], + "ciphertext": [ + 189, + 246, + 168, + 161, + 18, + 136, + 232, + 49, + 38, + 147, + 44, + 217, + 70 + ], + "tag": [ + 202, + 127, + 247, + 69, + 140, + 58, + 223, + 56, + 142, + 239, + 126, + 14, + 50, + 214, + 178, + 196 + ] + }, + { + "key": [ + 10, + 143, + 201, + 224, + 126, + 181, + 11, + 9, + 44, + 217, + 252, + 203, + 61, + 178, + 55, + 62 + ], + "nonce": [ + 55, + 29, + 10, + 248, + 11, + 178, + 15, + 46, + 173, + 9, + 220, + 34 + ], + "aad": [ + 159, + 66, + 151, + 104, + 71, + 83, + 29, + 223, + 228, + 40, + 105, + 79, + 97, + 38, + 11, + 42 + ], + "plaintext": [ + 120, + 38, + 191, + 1, + 233, + 98, + 162, + 1, + 245, + 200, + 231, + 247, + 66 + ], + "ciphertext": [ + 102, + 92, + 219, + 62, + 37, + 104, + 238, + 17, + 87, + 216, + 119, + 221, + 37 + ], + "tag": [ + 198, + 111, + 193, + 41, + 236, + 179, + 14, + 160, + 213, + 75, + 109, + 105, + 50, + 217, + 215, + 168 + ] + }, + { + "key": [ + 61, + 31, + 201, + 50, + 51, + 232, + 108, + 184, + 130, + 228, + 205, + 117, + 77, + 246, + 55, + 84 + ], + "nonce": [ + 30, + 222, + 140, + 173, + 199, + 139, + 180, + 115, + 60, + 52, + 27, + 172 + ], + "aad": [ + 88, + 7, + 200, + 86, + 148, + 79, + 238, + 30, + 108, + 46, + 112, + 173, + 154, + 8, + 222, + 0 + ], + "plaintext": [ + 116, + 35, + 43, + 254, + 220, + 55, + 126, + 253, + 90, + 99, + 171, + 119, + 204 + ], + "ciphertext": [ + 255, + 62, + 9, + 49, + 29, + 89, + 191, + 31, + 61, + 255, + 71, + 79, + 212 + ], + "tag": [ + 125, + 186, + 247, + 90, + 182, + 8, + 69, + 4, + 224, + 128, + 70, + 14, + 191, + 210, + 85, + 175 + ] + }, + { + "key": [ + 147, + 107, + 169, + 252, + 113, + 92, + 110, + 45, + 112, + 167, + 152, + 107, + 20, + 184, + 44, + 230 + ], + "nonce": [ + 69, + 179, + 35, + 157, + 4, + 91, + 213, + 110, + 165, + 160, + 231, + 127 + ], + "aad": [ + 162, + 87, + 13, + 149, + 72, + 189, + 108, + 5, + 248, + 36, + 87, + 120, + 113, + 120, + 78, + 228 + ], + "plaintext": [ + 148, + 18, + 85, + 54, + 151, + 4, + 236, + 25, + 43, + 171, + 28, + 240, + 57 + ], + "ciphertext": [ + 179, + 234, + 208, + 121, + 68, + 96, + 83, + 168, + 32, + 111, + 74, + 55, + 166 + ], + "tag": [ + 250, + 93, + 152, + 240, + 83, + 232, + 82, + 15, + 69, + 225, + 89, + 126, + 227, + 139, + 55, + 81 + ] + }, + { + "key": [ + 150, + 160, + 88, + 137, + 167, + 89, + 28, + 25, + 24, + 71, + 47, + 210, + 105, + 119, + 69, + 26 + ], + "nonce": [ + 125, + 128, + 73, + 42, + 254, + 252, + 232, + 13, + 166, + 104, + 159, + 252 + ], + "aad": [ + 244, + 255, + 163, + 106, + 71, + 140, + 121, + 94, + 13, + 40, + 211, + 127, + 169, + 230, + 252, + 194 + ], + "plaintext": [ + 176, + 155, + 45, + 197, + 197, + 70, + 58, + 3, + 221, + 92, + 155, + 14, + 207 + ], + "ciphertext": [ + 247, + 203, + 5, + 61, + 68, + 125, + 221, + 203, + 110, + 58, + 45, + 137, + 31 + ], + "tag": [ + 42, + 56, + 246, + 58, + 27, + 124, + 220, + 206, + 196, + 38, + 104, + 59, + 52, + 164, + 79, + 245 + ] + }, + { + "key": [ + 124, + 152, + 86, + 127, + 181, + 174, + 150, + 1, + 252, + 164, + 18, + 231, + 45, + 201, + 254, + 47 + ], + "nonce": [ + 18, + 24, + 206, + 105, + 7, + 62, + 239, + 210, + 90, + 121, + 68, + 230 + ], + "aad": [ + 223, + 66, + 3, + 195, + 64, + 45, + 43, + 50, + 139, + 203, + 68, + 231, + 104, + 62, + 8, + 171 + ], + "plaintext": [ + 13, + 247, + 93, + 57, + 216, + 250, + 204, + 58, + 204, + 189, + 239, + 200, + 124 + ], + "ciphertext": [ + 126, + 92, + 160, + 209, + 193, + 255, + 131, + 188, + 54, + 51, + 242, + 48, + 28 + ], + "tag": [ + 126, + 167, + 23, + 69, + 140, + 169, + 61, + 136, + 68, + 218, + 93, + 247, + 239, + 116, + 0, + 90 + ] + }, + { + "key": [ + 78, + 27, + 25, + 156, + 18, + 241, + 43, + 89, + 28, + 5, + 28, + 126, + 220, + 96, + 141, + 17 + ], + "nonce": [ + 164, + 189, + 58, + 247, + 243, + 93, + 15, + 162, + 31, + 115, + 100, + 30 + ], + "aad": [ + 218, + 226, + 205, + 116, + 145, + 149, + 188, + 251, + 103, + 166, + 99, + 120, + 158, + 133, + 153, + 94 + ], + "plaintext": [ + 5, + 30, + 213, + 215, + 0, + 167, + 229, + 153, + 144, + 240, + 53, + 137, + 40 + ], + "ciphertext": [ + 174, + 80, + 53, + 159, + 16, + 75, + 162, + 8, + 154, + 233, + 142, + 180, + 90 + ], + "tag": [ + 192, + 138, + 124, + 206, + 124, + 56, + 98, + 102, + 4, + 3, + 45, + 43, + 233, + 189, + 81, + 156 + ] + }, + { + "key": [ + 148, + 145, + 203, + 93, + 79, + 43, + 148, + 204, + 90, + 80, + 220, + 103, + 191, + 237, + 208, + 116 + ], + "nonce": [ + 131, + 119, + 57, + 150, + 7, + 65, + 142, + 141, + 81, + 218, + 197, + 234 + ], + "aad": [ + 151, + 45, + 156, + 72, + 105, + 97, + 51, + 74, + 252, + 16, + 71, + 101, + 194, + 134, + 50, + 83 + ], + "plaintext": [ + 42, + 30, + 80, + 204, + 181, + 165, + 43, + 227, + 211, + 56, + 232, + 240, + 166 + ], + "ciphertext": [ + 175, + 231, + 89, + 181, + 19, + 24, + 246, + 125, + 135, + 42, + 29, + 253, + 174 + ], + "tag": [ + 119, + 164, + 73, + 58, + 237, + 126, + 58, + 110, + 1, + 77, + 10, + 26, + 49, + 76, + 63, + 134 + ] + }, + { + "key": [ + 9, + 147, + 87, + 17, + 131, + 8, + 156, + 74, + 123, + 216, + 232, + 120, + 152, + 84, + 194, + 101 + ], + "nonce": [ + 215, + 44, + 230, + 219, + 51, + 179, + 62, + 42, + 45, + 67, + 13, + 46 + ], + "aad": [ + 228, + 114, + 82, + 210, + 168, + 239, + 81, + 144, + 250, + 243, + 40, + 23, + 101, + 136, + 96, + 155 + ], + "plaintext": [ + 218, + 247, + 243, + 236, + 46, + 37, + 146, + 198, + 88, + 71, + 115, + 79, + 64 + ], + "ciphertext": [ + 198, + 250, + 222, + 192, + 199, + 82, + 15, + 113, + 113, + 68, + 240, + 16, + 74 + ], + "tag": [ + 102, + 112, + 200, + 203, + 247, + 233, + 235, + 67, + 30, + 137, + 159, + 97, + 172, + 204, + 244, + 86 + ] + }, + { + "key": [ + 212, + 91, + 108, + 133, + 41, + 61, + 96, + 147, + 16, + 235, + 49, + 121, + 207, + 186, + 196, + 251 + ], + "nonce": [ + 176, + 35, + 40, + 48, + 44, + 196, + 105, + 205, + 161, + 199, + 235, + 72 + ], + "aad": [ + 116, + 202, + 91, + 70, + 171, + 49, + 161, + 27, + 75, + 76, + 37, + 54, + 102, + 132, + 75, + 50 + ], + "plaintext": [ + 112, + 245, + 175, + 140, + 29, + 169, + 135, + 246, + 171, + 93, + 234, + 49, + 222 + ], + "ciphertext": [ + 218, + 107, + 53, + 144, + 114, + 172, + 207, + 95, + 3, + 108, + 133, + 96, + 13 + ], + "tag": [ + 216, + 228, + 150, + 197, + 55, + 151, + 177, + 36, + 227, + 86, + 150, + 126, + 229, + 37, + 192, + 202 + ] + }, + { + "key": [ + 147, + 38, + 21, + 90, + 155, + 129, + 1, + 60, + 30, + 219, + 20, + 63, + 159, + 90, + 233, + 210 + ], + "nonce": [ + 201, + 83, + 131, + 235, + 48, + 80, + 235, + 234, + 77, + 235, + 128, + 233 + ], + "aad": [ + 100, + 167, + 63, + 4, + 151, + 116, + 100, + 54, + 172, + 148, + 195, + 193, + 142, + 30, + 246, + 225 + ], + "plaintext": [ + 170, + 128, + 203, + 235, + 251, + 1, + 176, + 53, + 164, + 225, + 229, + 14, + 53 + ], + "ciphertext": [ + 69, + 236, + 141, + 230, + 51, + 199, + 187, + 88, + 92, + 10, + 127, + 234, + 31 + ], + "tag": [ + 83, + 123, + 97, + 3, + 176, + 247, + 197, + 220, + 232, + 43, + 250, + 55, + 194, + 115, + 72, + 119 + ] + }, + { + "key": [ + 145, + 146, + 206, + 77, + 56, + 55, + 82, + 233, + 217, + 198, + 107, + 147, + 239, + 127, + 5, + 171 + ], + "nonce": [ + 173, + 171, + 211, + 186, + 164, + 55, + 70, + 151, + 197, + 59, + 66, + 137 + ], + "aad": [ + 20, + 202, + 208, + 203, + 23, + 54, + 204, + 222, + 115, + 248, + 104, + 151, + 234, + 1, + 117, + 112 + ], + "plaintext": [ + 197, + 91, + 93, + 22, + 227, + 206, + 226, + 43, + 173, + 31, + 84, + 32, + 186 + ], + "ciphertext": [ + 58, + 162, + 42, + 87, + 100, + 98, + 41, + 253, + 51, + 187, + 250, + 230, + 206 + ], + "tag": [ + 92, + 231, + 205, + 67, + 152, + 35, + 83, + 143, + 188, + 25, + 72, + 134, + 52, + 143, + 240, + 41 + ] + }, + { + "key": [ + 61, + 209, + 4, + 41, + 126, + 128, + 61, + 194, + 43, + 143, + 17, + 241, + 149, + 28, + 133, + 8 + ], + "nonce": [ + 138, + 189, + 31, + 216, + 205, + 136, + 239, + 132, + 142, + 140, + 224, + 130 + ], + "aad": [ + 150, + 246, + 200, + 42, + 169, + 60, + 204, + 164, + 112, + 86, + 239, + 195, + 172, + 151, + 22, + 19 + ], + "plaintext": [ + 225, + 235, + 83, + 112, + 76, + 205, + 93, + 121, + 146, + 241, + 201, + 16, + 151 + ], + "ciphertext": [ + 142, + 65, + 37, + 81, + 72, + 112, + 0, + 63, + 11, + 14, + 128, + 68, + 168 + ], + "tag": [ + 217, + 81, + 4, + 124, + 216, + 213, + 12, + 165, + 247, + 255, + 222, + 191, + 120, + 114, + 92, + 86 + ] + }, + { + "key": [ + 254, + 1, + 33, + 244, + 46, + 89, + 159, + 136, + 255, + 2, + 169, + 133, + 64, + 62, + 25, + 187 + ], + "nonce": [ + 59, + 185, + 235, + 119, + 36, + 203, + 225, + 148, + 61, + 67, + 222, + 33 + ], + "aad": [ + 38, + 98, + 216, + 149, + 3, + 91, + 101, + 25, + 243, + 81, + 14, + 174, + 15, + 170, + 57, + 0, + 173, + 35, + 207, + 223 + ], + "plaintext": [ + 253, + 51, + 28, + 168, + 100, + 96, + 145, + 194, + 159, + 33, + 229, + 240, + 161 + ], + "ciphertext": [ + 89, + 254, + 41, + 176, + 123, + 13, + 232, + 216, + 105, + 239, + 187, + 217, + 180 + ], + "tag": [ + 210, + 76, + 62, + 156, + 28, + 115, + 192, + 175, + 16, + 151, + 226, + 96, + 97, + 200, + 87, + 222 + ] + }, + { + "key": [ + 84, + 78, + 200, + 47, + 131, + 127, + 190, + 86, + 31, + 55, + 27, + 38, + 108, + 197, + 46, + 213 + ], + "nonce": [ + 183, + 86, + 149, + 42, + 14, + 152, + 207, + 76, + 176, + 36, + 164, + 153 + ], + "aad": [ + 205, + 10, + 36, + 253, + 15, + 106, + 105, + 58, + 21, + 120, + 185, + 223, + 210, + 162, + 18, + 233, + 144, + 170, + 102, + 43 + ], + "plaintext": [ + 162, + 232, + 31, + 120, + 184, + 227, + 227, + 158, + 108, + 223, + 47, + 41, + 130 + ], + "ciphertext": [ + 164, + 240, + 137, + 151, + 226, + 217, + 60, + 60, + 98, + 33, + 55, + 249, + 168 + ], + "tag": [ + 5, + 156, + 242, + 102, + 36, + 2, + 54, + 253, + 63, + 65, + 163, + 244, + 250, + 187, + 54, + 191 + ] + }, + { + "key": [ + 145, + 183, + 62, + 32, + 97, + 176, + 43, + 30, + 94, + 76, + 21, + 12, + 225, + 223, + 77, + 39 + ], + "nonce": [ + 139, + 21, + 89, + 124, + 132, + 219, + 98, + 226, + 216, + 176, + 56, + 87 + ], + "aad": [ + 235, + 167, + 241, + 160, + 96, + 232, + 31, + 74, + 231, + 167, + 115, + 70, + 215, + 77, + 174, + 146, + 99, + 236, + 40, + 76 + ], + "plaintext": [ + 33, + 225, + 180, + 180, + 5, + 5, + 4, + 8, + 176, + 142, + 94, + 42, + 151 + ], + "ciphertext": [ + 15, + 129, + 155, + 37, + 252, + 104, + 60, + 24, + 37, + 51, + 80, + 58, + 216 + ], + "tag": [ + 90, + 29, + 166, + 41, + 15, + 239, + 128, + 31, + 33, + 49, + 97, + 79, + 124, + 210, + 208, + 191 + ] + }, + { + "key": [ + 230, + 161, + 228, + 38, + 14, + 251, + 43, + 179, + 7, + 58, + 26, + 180, + 117, + 233, + 1, + 185 + ], + "nonce": [ + 190, + 68, + 95, + 186, + 188, + 56, + 102, + 215, + 2, + 150, + 91, + 8 + ], + "aad": [ + 148, + 82, + 19, + 114, + 37, + 222, + 100, + 79, + 148, + 85, + 107, + 56, + 42, + 193, + 57, + 21, + 232, + 38, + 25, + 19 + ], + "plaintext": [ + 40, + 151, + 215, + 124, + 127, + 32, + 103, + 156, + 191, + 39, + 24, + 26, + 202 + ], + "ciphertext": [ + 213, + 110, + 45, + 109, + 82, + 146, + 50, + 5, + 41, + 31, + 255, + 165, + 10 + ], + "tag": [ + 166, + 172, + 241, + 156, + 84, + 52, + 249, + 94, + 51, + 56, + 39, + 237, + 156, + 123, + 136, + 236 + ] + }, + { + "key": [ + 73, + 193, + 139, + 237, + 148, + 18, + 52, + 106, + 142, + 240, + 35, + 81, + 205, + 70, + 128, + 214 + ], + "nonce": [ + 123, + 90, + 126, + 155, + 238, + 197, + 182, + 39, + 247, + 139, + 253, + 29 + ], + "aad": [ + 37, + 27, + 158, + 147, + 93, + 114, + 193, + 237, + 5, + 121, + 92, + 116, + 200, + 139, + 109, + 74, + 3, + 189, + 114, + 155 + ], + "plaintext": [ + 186, + 254, + 133, + 28, + 128, + 15, + 109, + 246, + 126, + 148, + 31, + 180, + 150 + ], + "ciphertext": [ + 111, + 12, + 46, + 235, + 10, + 55, + 213, + 29, + 120, + 49, + 76, + 52, + 20 + ], + "tag": [ + 26, + 117, + 217, + 98, + 211, + 66, + 5, + 214, + 15, + 121, + 228, + 222, + 135, + 56, + 16, + 70 + ] + }, + { + "key": [ + 237, + 3, + 52, + 35, + 158, + 182, + 241, + 238, + 29, + 104, + 109, + 241, + 99, + 210, + 25, + 183 + ], + "nonce": [ + 97, + 70, + 51, + 142, + 64, + 252, + 216, + 191, + 38, + 75, + 200, + 59 + ], + "aad": [ + 205, + 186, + 142, + 181, + 113, + 48, + 117, + 73, + 126, + 181, + 171, + 241, + 67, + 64, + 69, + 160, + 16, + 248, + 24, + 50 + ], + "plaintext": [ + 149, + 77, + 223, + 85, + 59, + 246, + 100, + 115, + 101, + 113, + 16, + 160, + 40 + ], + "ciphertext": [ + 62, + 183, + 109, + 253, + 64, + 197, + 235, + 200, + 64, + 149, + 29, + 27, + 40 + ], + "tag": [ + 93, + 90, + 161, + 220, + 74, + 102, + 62, + 235, + 132, + 126, + 84, + 15, + 154, + 70, + 129, + 85 + ] + }, + { + "key": [ + 20, + 171, + 77, + 58, + 145, + 232, + 248, + 50, + 14, + 219, + 165, + 176, + 69, + 185, + 71, + 74 + ], + "nonce": [ + 131, + 198, + 172, + 151, + 112, + 74, + 253, + 210, + 79, + 190, + 62, + 186 + ], + "aad": [ + 227, + 152, + 30, + 162, + 231, + 70, + 137, + 115, + 166, + 169, + 152, + 222, + 183, + 103, + 109, + 6, + 99, + 11, + 173, + 71 + ], + "plaintext": [ + 222, + 95, + 21, + 33, + 206, + 148, + 35, + 82, + 105, + 50, + 145, + 120, + 99 + ], + "ciphertext": [ + 25, + 147, + 106, + 231, + 214, + 98, + 8, + 153, + 100, + 154, + 92, + 120, + 135 + ], + "tag": [ + 102, + 168, + 5, + 53, + 59, + 222, + 11, + 19, + 21, + 247, + 114, + 212, + 158, + 234, + 248, + 242 + ] + }, + { + "key": [ + 248, + 34, + 195, + 158, + 171, + 163, + 235, + 179, + 216, + 181, + 140, + 255, + 56, + 69, + 172, + 89 + ], + "nonce": [ + 31, + 93, + 17, + 196, + 105, + 233, + 251, + 116, + 241, + 157, + 133, + 129 + ], + "aad": [ + 179, + 56, + 113, + 246, + 82, + 51, + 187, + 43, + 167, + 115, + 205, + 143, + 237, + 181, + 23, + 23, + 154, + 42, + 36, + 165 + ], + "plaintext": [ + 192, + 250, + 200, + 124, + 165, + 24, + 171, + 34, + 133, + 60, + 143, + 160, + 43 + ], + "ciphertext": [ + 160, + 114, + 56, + 25, + 86, + 33, + 9, + 37, + 20, + 142, + 59, + 197, + 93 + ], + "tag": [ + 247, + 22, + 236, + 1, + 47, + 127, + 155, + 233, + 136, + 169, + 228, + 80, + 218, + 122, + 162, + 254 + ] + }, + { + "key": [ + 197, + 102, + 233, + 153, + 92, + 3, + 167, + 119, + 249, + 153, + 148, + 70, + 56, + 46, + 242, + 252 + ], + "nonce": [ + 79, + 52, + 52, + 119, + 56, + 127, + 72, + 185, + 198, + 209, + 94, + 105 + ], + "aad": [ + 194, + 183, + 59, + 240, + 209, + 171, + 214, + 212, + 132, + 223, + 114, + 90, + 118, + 15, + 24, + 75, + 195, + 21, + 224, + 186 + ], + "plaintext": [ + 169, + 234, + 253, + 137, + 3, + 199, + 24, + 98, + 199, + 201, + 156, + 240, + 104 + ], + "ciphertext": [ + 159, + 149, + 81, + 163, + 173, + 1, + 124, + 63, + 165, + 24, + 150, + 71, + 4 + ], + "tag": [ + 21, + 56, + 63, + 184, + 172, + 226, + 224, + 1, + 193, + 148, + 71, + 64, + 49, + 193, + 78, + 135 + ] + }, + { + "key": [ + 250, + 47, + 224, + 27, + 124, + 180, + 202, + 36, + 171, + 165, + 136, + 13, + 162, + 104, + 57, + 138 + ], + "nonce": [ + 147, + 241, + 157, + 10, + 142, + 223, + 31, + 41, + 54, + 71, + 67, + 242 + ], + "aad": [ + 232, + 15, + 51, + 126, + 181, + 108, + 51, + 109, + 30, + 146, + 141, + 179, + 183, + 238, + 238, + 150, + 142, + 47, + 117, + 189 + ], + "plaintext": [ + 0, + 108, + 59, + 6, + 129, + 242, + 26, + 215, + 5, + 207, + 148, + 208, + 112 + ], + "ciphertext": [ + 167, + 59, + 49, + 76, + 127, + 11, + 189, + 121, + 238, + 86, + 189, + 119, + 187 + ], + "tag": [ + 210, + 249, + 236, + 200, + 10, + 90, + 226, + 225, + 210, + 115, + 91, + 159, + 191, + 1, + 190, + 37 + ] + }, + { + "key": [ + 119, + 179, + 73, + 112, + 212, + 48, + 0, + 105, + 224, + 9, + 44, + 214, + 74, + 209, + 115, + 5 + ], + "nonce": [ + 216, + 142, + 118, + 129, + 79, + 60, + 247, + 162, + 248, + 135, + 227, + 113 + ], + "aad": [ + 124, + 119, + 32, + 16, + 232, + 59, + 239, + 236, + 34, + 246, + 174, + 190, + 142, + 24, + 160, + 67, + 127, + 80, + 165, + 115 + ], + "plaintext": [ + 78, + 101, + 164, + 106, + 69, + 121, + 240, + 129, + 48, + 39, + 46, + 92, + 131 + ], + "ciphertext": [ + 210, + 216, + 255, + 211, + 248, + 65, + 230, + 3, + 159, + 29, + 85, + 25, + 5 + ], + "tag": [ + 238, + 44, + 115, + 196, + 85, + 8, + 29, + 132, + 166, + 49, + 177, + 138, + 127, + 229, + 247, + 137 + ] + }, + { + "key": [ + 60, + 28, + 42, + 174, + 57, + 84, + 214, + 246, + 69, + 206, + 42, + 105, + 122, + 79, + 58, + 248 + ], + "nonce": [ + 4, + 181, + 79, + 100, + 71, + 235, + 188, + 251, + 218, + 87, + 68, + 90 + ], + "aad": [ + 231, + 169, + 213, + 200, + 50, + 130, + 120, + 49, + 29, + 202, + 62, + 132, + 218, + 43, + 240, + 245, + 115, + 25, + 141, + 79 + ], + "plaintext": [ + 247, + 62, + 34, + 107, + 80, + 167, + 85, + 88, + 163, + 137, + 204, + 215, + 56 + ], + "ciphertext": [ + 119, + 14, + 75, + 121, + 139, + 145, + 133, + 14, + 196, + 233, + 1, + 54, + 202 + ], + "tag": [ + 140, + 185, + 206, + 44, + 144, + 65, + 127, + 28, + 73, + 162, + 53, + 222, + 155, + 42, + 218, + 45 + ] + }, + { + "key": [ + 21, + 202, + 41, + 16, + 223, + 78, + 67, + 196, + 74, + 124, + 1, + 212, + 133, + 185, + 145, + 87 + ], + "nonce": [ + 74, + 101, + 202, + 119, + 221, + 225, + 75, + 191, + 19, + 29, + 213, + 151 + ], + "aad": [ + 249, + 1, + 30, + 44, + 251, + 156, + 130, + 211, + 127, + 107, + 63, + 42, + 247, + 48, + 162, + 226, + 140, + 3, + 111, + 44 + ], + "plaintext": [ + 120, + 103, + 68, + 179, + 148, + 228, + 11, + 254, + 93, + 185, + 56, + 192, + 173 + ], + "ciphertext": [ + 67, + 192, + 15, + 172, + 124, + 17, + 195, + 39, + 48, + 120, + 240, + 159, + 226 + ], + "tag": [ + 149, + 91, + 234, + 168, + 119, + 55, + 211, + 9, + 75, + 172, + 196, + 42, + 21, + 152, + 109, + 131 + ] + }, + { + "key": [ + 153, + 137, + 144, + 254, + 74, + 154, + 108, + 86, + 239, + 223, + 29, + 234, + 196, + 26, + 30, + 245 + ], + "nonce": [ + 27, + 122, + 118, + 100, + 54, + 244, + 166, + 116, + 181, + 237, + 134, + 171 + ], + "aad": [ + 46, + 186, + 111, + 44, + 97, + 112, + 73, + 23, + 67, + 69, + 7, + 244, + 162, + 219, + 22, + 196, + 144, + 107, + 180, + 229 + ], + "plaintext": [ + 229, + 58, + 153, + 84, + 195, + 148, + 54, + 145, + 222, + 229, + 177, + 121, + 145 + ], + "ciphertext": [ + 229, + 104, + 32, + 69, + 244, + 56, + 244, + 169, + 106, + 200, + 112, + 105, + 11 + ], + "tag": [ + 26, + 253, + 220, + 3, + 128, + 158, + 86, + 83, + 33, + 234, + 102, + 216, + 200, + 58, + 50, + 74 + ] + }, + { + "key": [ + 38, + 139, + 167, + 104, + 22, + 208, + 14, + 32, + 153, + 125, + 162, + 104, + 189, + 143, + 170, + 24 + ], + "nonce": [ + 33, + 205, + 93, + 33, + 237, + 25, + 54, + 18, + 253, + 109, + 184, + 84 + ], + "aad": [ + 25, + 113, + 185, + 13, + 160, + 85, + 78, + 231, + 182, + 176, + 165, + 233, + 167, + 130, + 240, + 93, + 81, + 28, + 27, + 153 + ], + "plaintext": [ + 22, + 51, + 153, + 134, + 208, + 146, + 2, + 126, + 124, + 190, + 206, + 15, + 182 + ], + "ciphertext": [ + 124, + 253, + 83, + 184, + 195, + 200, + 52, + 194, + 19, + 217, + 134, + 4, + 153 + ], + "tag": [ + 31, + 133, + 34, + 191, + 171, + 151, + 190, + 196, + 54, + 215, + 104, + 51, + 42, + 227, + 124, + 32 + ] + }, + { + "key": [ + 203, + 211, + 184, + 219, + 252, + 251, + 17, + 206, + 52, + 87, + 6, + 230, + 205, + 115, + 136, + 26 + ], + "nonce": [ + 220, + 98, + 187, + 104, + 208, + 236, + 154, + 93, + 117, + 157, + 103, + 65 + ], + "aad": [ + 9, + 68, + 182, + 97, + 254, + 98, + 148, + 243, + 201, + 42, + 187, + 8, + 126, + 193, + 178, + 89, + 176, + 50, + 220, + 78, + 12, + 95, + 40, + 104, + 28, + 190, + 110, + 99, + 194, + 23, + 143, + 71, + 67, + 38, + 243, + 90, + 211, + 202, + 128, + 194, + 142, + 52, + 133, + 231, + 229, + 178, + 82, + 200 + ], + "plaintext": [ + 133, + 248, + 59, + 245, + 152, + 223, + 213, + 91, + 200, + 191, + 222, + 42, + 100 + ], + "ciphertext": [ + 32, + 111, + 107, + 59, + 176, + 50, + 223, + 236, + 211, + 159, + 131, + 64, + 177 + ], + "tag": [ + 66, + 90, + 33, + 178, + 234, + 144, + 88, + 12, + 136, + 145, + 52, + 3, + 43, + 145, + 75, + 181 + ] + }, + { + "key": [ + 167, + 143, + 52, + 205, + 12, + 172, + 112, + 170, + 182, + 74, + 202, + 225, + 142, + 60, + 190, + 238 + ], + "nonce": [ + 60, + 136, + 87, + 4, + 152, + 218, + 150, + 231, + 181, + 44, + 121, + 41 + ], + "aad": [ + 54, + 182, + 111, + 248, + 30, + 194, + 58, + 40, + 148, + 76, + 152, + 210, + 131, + 76, + 199, + 100, + 187, + 112, + 112, + 63, + 11, + 38, + 224, + 121, + 182, + 235, + 0, + 142, + 193, + 28, + 207, + 181, + 74, + 24, + 154, + 211, + 147, + 135, + 143, + 8, + 36, + 67, + 106, + 230, + 158, + 126, + 45, + 140 + ], + "plaintext": [ + 191, + 97, + 177, + 251, + 59, + 36, + 80, + 108, + 200, + 199, + 48, + 211, + 153 + ], + "ciphertext": [ + 247, + 32, + 87, + 248, + 115, + 173, + 18, + 181, + 225, + 156, + 228, + 51, + 224 + ], + "tag": [ + 31, + 234, + 91, + 65, + 118, + 70, + 75, + 31, + 93, + 206, + 17, + 85, + 138, + 117, + 236, + 33 + ] + }, + { + "key": [ + 14, + 3, + 138, + 19, + 104, + 153, + 158, + 46, + 112, + 182, + 227, + 80, + 224, + 22, + 132, + 189 + ], + "nonce": [ + 165, + 137, + 82, + 184, + 19, + 84, + 32, + 205, + 15, + 97, + 190, + 24 + ], + "aad": [ + 118, + 82, + 3, + 179, + 214, + 21, + 55, + 190, + 40, + 131, + 251, + 169, + 137, + 156, + 63, + 62, + 255, + 96, + 203, + 151, + 20, + 229, + 77, + 227, + 167, + 138, + 150, + 219, + 242, + 156, + 245, + 61, + 130, + 17, + 46, + 25, + 177, + 1, + 65, + 241, + 59, + 17, + 98, + 122, + 143, + 165, + 80, + 38 + ], + "plaintext": [ + 128, + 27, + 186, + 191, + 144, + 143, + 240, + 77, + 88, + 86, + 202, + 220, + 43 + ], + "ciphertext": [ + 127, + 15, + 53, + 203, + 21, + 251, + 78, + 126, + 56, + 32, + 217, + 171, + 31 + ], + "tag": [ + 141, + 206, + 100, + 55, + 32, + 217, + 214, + 249, + 15, + 19, + 161, + 85, + 224, + 190, + 89, + 54 + ] + }, + { + "key": [ + 182, + 157, + 130, + 231, + 139, + 34, + 164, + 115, + 175, + 98, + 52, + 6, + 107, + 137, + 23, + 120 + ], + "nonce": [ + 4, + 21, + 171, + 47, + 50, + 210, + 161, + 80, + 6, + 195, + 189, + 213 + ], + "aad": [ + 240, + 190, + 101, + 16, + 94, + 28, + 212, + 253, + 26, + 39, + 47, + 127, + 109, + 185, + 88, + 4, + 11, + 68, + 237, + 208, + 96, + 139, + 34, + 37, + 120, + 156, + 243, + 66, + 23, + 207, + 205, + 106, + 88, + 121, + 184, + 231, + 157, + 250, + 125, + 36, + 52, + 90, + 210, + 15, + 12, + 79, + 154, + 28 + ], + "plaintext": [ + 212, + 171, + 52, + 110, + 218, + 202, + 92, + 132, + 212, + 91, + 69, + 198, + 254 + ], + "ciphertext": [ + 173, + 119, + 201, + 28, + 107, + 166, + 203, + 41, + 235, + 94, + 79, + 96, + 113 + ], + "tag": [ + 246, + 112, + 97, + 219, + 222, + 209, + 168, + 223, + 85, + 254, + 159, + 205, + 104, + 246, + 17, + 104 + ] + }, + { + "key": [ + 120, + 250, + 249, + 55, + 117, + 143, + 52, + 182, + 211, + 20, + 226, + 250, + 48, + 246, + 12, + 46 + ], + "nonce": [ + 133, + 201, + 239, + 14, + 23, + 235, + 203, + 183, + 34, + 123, + 164, + 193 + ], + "aad": [ + 112, + 254, + 198, + 230, + 8, + 182, + 38, + 66, + 40, + 184, + 34, + 231, + 73, + 14, + 94, + 118, + 57, + 132, + 148, + 198, + 72, + 157, + 229, + 232, + 57, + 251, + 128, + 81, + 52, + 66, + 205, + 13, + 252, + 248, + 131, + 0, + 9, + 149, + 24, + 82, + 19, + 226, + 131, + 244, + 146, + 52, + 40, + 11 + ], + "plaintext": [ + 10, + 217, + 26, + 139, + 228, + 204, + 214, + 238, + 12, + 231, + 84, + 19, + 163 + ], + "ciphertext": [ + 66, + 152, + 208, + 161, + 234, + 76, + 84, + 149, + 0, + 33, + 217, + 25, + 33 + ], + "tag": [ + 25, + 137, + 59, + 131, + 253, + 36, + 168, + 194, + 27, + 180, + 255, + 20, + 97, + 44, + 219, + 39 + ] + }, + { + "key": [ + 248, + 18, + 98, + 124, + 182, + 220, + 89, + 33, + 211, + 86, + 125, + 209, + 127, + 31, + 59, + 154 + ], + "nonce": [ + 55, + 190, + 185, + 192, + 96, + 242, + 64, + 217, + 255, + 120, + 200, + 68 + ], + "aad": [ + 162, + 127, + 216, + 17, + 51, + 14, + 250, + 103, + 43, + 191, + 161, + 203, + 42, + 34, + 31, + 164, + 91, + 171, + 136, + 197, + 24, + 62, + 237, + 99, + 131, + 227, + 76, + 126, + 116, + 80, + 253, + 87, + 127, + 108, + 120, + 60, + 117, + 217, + 236, + 175, + 116, + 187, + 42, + 210, + 178, + 232, + 193, + 67 + ], + "plaintext": [ + 219, + 206, + 82, + 53, + 188, + 205, + 11, + 198, + 36, + 155, + 48, + 233, + 177 + ], + "ciphertext": [ + 16, + 10, + 176, + 73, + 96, + 167, + 98, + 219, + 115, + 23, + 70, + 102, + 180 + ], + "tag": [ + 18, + 33, + 114, + 238, + 48, + 147, + 184, + 203, + 35, + 138, + 124, + 153, + 29, + 163, + 185, + 79 + ] + }, + { + "key": [ + 164, + 149, + 248, + 39, + 81, + 191, + 119, + 129, + 254, + 227, + 109, + 38, + 86, + 7, + 170, + 107 + ], + "nonce": [ + 114, + 154, + 81, + 59, + 175, + 28, + 205, + 28, + 151, + 49, + 23, + 0 + ], + "aad": [ + 58, + 68, + 167, + 234, + 109, + 62, + 209, + 48, + 5, + 212, + 108, + 25, + 245, + 236, + 125, + 47, + 126, + 80, + 232, + 162, + 104, + 252, + 73, + 227, + 198, + 254, + 21, + 180, + 27, + 111, + 110, + 167, + 36, + 93, + 136, + 203, + 53, + 142, + 83, + 205, + 186, + 130, + 207, + 41, + 126, + 160, + 234, + 151 + ], + "plaintext": [ + 10, + 196, + 19, + 250, + 83, + 59, + 1, + 190, + 69, + 158, + 149, + 215, + 132 + ], + "ciphertext": [ + 208, + 95, + 82, + 168, + 117, + 245, + 109, + 58, + 105, + 113, + 73, + 91, + 123 + ], + "tag": [ + 20, + 174, + 55, + 138, + 95, + 117, + 179, + 134, + 32, + 33, + 148, + 198, + 119, + 55, + 120, + 3 + ] + }, + { + "key": [ + 99, + 238, + 210, + 98, + 60, + 128, + 234, + 28, + 93, + 6, + 160, + 0, + 60, + 75, + 48, + 101 + ], + "nonce": [ + 58, + 39, + 111, + 67, + 97, + 204, + 109, + 123, + 219, + 52, + 9, + 134 + ], + "aad": [ + 212, + 132, + 100, + 111, + 220, + 169, + 245, + 211, + 212, + 250, + 44, + 133, + 237, + 20, + 95, + 153, + 227, + 199, + 63, + 77, + 129, + 246, + 192, + 142, + 173, + 243, + 24, + 105, + 75, + 215, + 204, + 148, + 56, + 44, + 199, + 58, + 86, + 16, + 249, + 203, + 253, + 153, + 135, + 220, + 22, + 125, + 103, + 12 + ], + "plaintext": [ + 101, + 6, + 123, + 40, + 29, + 90, + 175, + 192, + 20, + 109, + 32, + 111, + 226 + ], + "ciphertext": [ + 76, + 242, + 255, + 113, + 228, + 74, + 57, + 235, + 106, + 150, + 17, + 225, + 80 + ], + "tag": [ + 17, + 62, + 125, + 35, + 153, + 70, + 215, + 132, + 195, + 49, + 188, + 205, + 94, + 9, + 129, + 148 + ] + }, + { + "key": [ + 58, + 216, + 83, + 4, + 180, + 38, + 125, + 214, + 3, + 7, + 12, + 26, + 153, + 158, + 182, + 88 + ], + "nonce": [ + 42, + 2, + 166, + 34, + 13, + 57, + 93, + 201, + 31, + 160, + 210, + 32 + ], + "aad": [ + 122, + 21, + 17, + 202, + 184, + 170, + 159, + 114, + 119, + 247, + 178, + 108, + 222, + 230, + 2, + 228, + 166, + 8, + 181, + 86, + 90, + 32, + 238, + 221, + 102, + 215, + 5, + 7, + 169, + 14, + 121, + 218, + 101, + 33, + 202, + 225, + 226, + 202, + 129, + 7, + 113, + 57, + 37, + 103, + 175, + 81, + 216, + 131 + ], + "plaintext": [ + 224, + 98, + 10, + 158, + 40, + 173, + 141, + 186, + 50, + 182, + 1, + 198, + 98 + ], + "ciphertext": [ + 207, + 56, + 247, + 171, + 175, + 79, + 146, + 65, + 78, + 203, + 112, + 33, + 168 + ], + "tag": [ + 139, + 235, + 176, + 182, + 44, + 129, + 164, + 163, + 174, + 118, + 93, + 188, + 124, + 135, + 71, + 168 + ] + }, + { + "key": [ + 99, + 1, + 11, + 117, + 173, + 163, + 204, + 208, + 193, + 51, + 134, + 19, + 213, + 126, + 63, + 83 + ], + "nonce": [ + 152, + 152, + 185, + 18, + 218, + 10, + 47, + 22, + 156, + 59, + 249, + 7 + ], + "aad": [ + 86, + 94, + 30, + 88, + 16, + 137, + 9, + 132, + 81, + 204, + 175, + 29, + 89, + 77, + 27, + 78, + 219, + 220, + 213, + 203, + 0, + 186, + 75, + 46, + 8, + 228, + 219, + 120, + 12, + 232, + 37, + 141, + 244, + 29, + 1, + 219, + 221, + 80, + 82, + 27, + 117, + 167, + 42, + 130, + 89, + 247, + 3, + 33 + ], + "plaintext": [ + 252, + 16, + 216, + 92, + 181, + 72, + 91, + 226, + 99, + 55, + 74, + 170, + 223 + ], + "ciphertext": [ + 143, + 35, + 144, + 232, + 139, + 198, + 241, + 142, + 205, + 193, + 161, + 185, + 210 + ], + "tag": [ + 21, + 196, + 14, + 152, + 182, + 189, + 91, + 7, + 212, + 117, + 119, + 39, + 173, + 107, + 123, + 113 + ] + }, + { + "key": [ + 210, + 161, + 129, + 136, + 187, + 136, + 49, + 46, + 193, + 137, + 22, + 67, + 27, + 109, + 216, + 128 + ], + "nonce": [ + 174, + 223, + 46, + 251, + 128, + 182, + 51, + 215, + 175, + 190, + 90, + 81 + ], + "aad": [ + 82, + 73, + 41, + 33, + 246, + 183, + 110, + 136, + 139, + 170, + 90, + 76, + 179, + 145, + 175, + 4, + 250, + 235, + 49, + 191, + 0, + 232, + 237, + 67, + 99, + 72, + 47, + 169, + 81, + 72, + 245, + 115, + 185, + 173, + 190, + 186, + 191, + 72, + 211, + 173, + 51, + 203, + 94, + 211, + 192, + 214, + 223, + 97 + ], + "plaintext": [ + 52, + 63, + 131, + 99, + 102, + 32, + 119, + 251, + 10, + 181, + 11, + 162, + 132 + ], + "ciphertext": [ + 151, + 166, + 244, + 74, + 4, + 5, + 88, + 80, + 119, + 155, + 199, + 8, + 66 + ], + "tag": [ + 95, + 251, + 117, + 181, + 139, + 69, + 114, + 54, + 111, + 176, + 6, + 69, + 95, + 105, + 47, + 147 + ] + }, + { + "key": [ + 123, + 59, + 129, + 250, + 135, + 246, + 252, + 32, + 121, + 94, + 95, + 227, + 63, + 224, + 209, + 232 + ], + "nonce": [ + 184, + 88, + 18, + 126, + 17, + 234, + 13, + 91, + 165, + 35, + 247, + 206 + ], + "aad": [ + 194, + 61, + 76, + 247, + 75, + 215, + 106, + 222, + 224, + 151, + 62, + 75, + 58, + 195, + 26, + 150, + 253, + 235, + 15, + 36, + 85, + 224, + 68, + 210, + 209, + 184, + 46, + 189, + 25, + 55, + 224, + 150, + 35, + 146, + 28, + 129, + 182, + 161, + 185, + 105, + 139, + 91, + 9, + 123, + 124, + 92, + 72, + 61 + ], + "plaintext": [ + 229, + 116, + 146, + 12, + 219, + 163, + 82, + 75, + 172, + 140, + 34, + 148, + 191 + ], + "ciphertext": [ + 1, + 106, + 123, + 87, + 219, + 119, + 143, + 208, + 25, + 98, + 128, + 22, + 246 + ], + "tag": [ + 232, + 3, + 80, + 34, + 176, + 94, + 76, + 16, + 121, + 35, + 33, + 209, + 149, + 183, + 88, + 84 + ] + }, + { + "key": [ + 133, + 44, + 52, + 89, + 30, + 127, + 254, + 240, + 146, + 89, + 169, + 237, + 242, + 80, + 32, + 225 + ], + "nonce": [ + 158, + 66, + 67, + 245, + 53, + 109, + 72, + 248, + 83, + 204, + 58, + 203 + ], + "aad": [ + 138, + 69, + 20, + 165, + 231, + 212, + 226, + 224, + 54, + 73, + 11, + 84, + 18, + 6, + 191, + 230, + 71, + 28, + 20, + 187, + 80, + 175, + 111, + 200, + 105, + 4, + 139, + 174, + 149, + 75, + 93, + 216, + 19, + 66, + 147, + 89, + 238, + 94, + 239, + 35, + 238, + 66, + 234, + 53, + 224, + 195, + 107, + 184 + ], + "plaintext": [ + 201, + 145, + 56, + 156, + 36, + 44, + 72, + 227, + 26, + 154, + 224, + 13, + 89 + ], + "ciphertext": [ + 92, + 49, + 153, + 131, + 229, + 226, + 118, + 101, + 143, + 16, + 165, + 142, + 219 + ], + "tag": [ + 83, + 67, + 8, + 109, + 74, + 192, + 228, + 94, + 74, + 220, + 109, + 194, + 125, + 86, + 98, + 150 + ] + }, + { + "key": [ + 185, + 132, + 15, + 28, + 4, + 247, + 201, + 233, + 178, + 201, + 190, + 192, + 198, + 23, + 103, + 56 + ], + "nonce": [ + 122, + 244, + 98, + 204, + 137, + 18, + 112, + 254, + 120, + 86, + 104, + 144 + ], + "aad": [ + 73, + 62, + 248, + 60, + 24, + 56, + 156, + 30, + 82, + 5, + 13, + 37, + 105, + 240, + 214, + 249, + 85, + 207, + 142, + 118, + 207, + 10, + 22, + 151, + 255, + 203, + 22, + 101, + 226, + 133, + 254, + 110, + 53, + 149, + 244, + 86, + 207, + 247, + 243, + 47, + 235, + 123, + 222, + 76, + 200, + 45, + 78, + 187 + ], + "plaintext": [ + 201, + 23, + 22, + 133, + 40, + 75, + 32, + 91, + 244, + 253, + 157, + 63, + 69 + ], + "ciphertext": [ + 152, + 140, + 44, + 61, + 243, + 124, + 104, + 252, + 139, + 199, + 162, + 155, + 17 + ], + "tag": [ + 216, + 27, + 11, + 195, + 84, + 63, + 239, + 74, + 146, + 152, + 103, + 191, + 246, + 58, + 28, + 23 + ] + }, + { + "key": [ + 148, + 73, + 4, + 48, + 113, + 222, + 144, + 79, + 94, + 110, + 121, + 34, + 178, + 99, + 241, + 34 + ], + "nonce": [ + 57, + 240, + 113, + 62, + 96, + 203, + 200, + 228, + 30, + 77, + 115, + 40 + ], + "aad": [ + 11, + 122, + 37, + 227, + 227, + 2, + 112, + 149, + 119, + 47, + 63, + 139, + 131, + 54, + 129, + 59, + 96, + 112, + 49, + 237, + 221, + 111, + 53, + 74, + 23, + 30, + 75, + 88, + 85, + 4, + 149, + 44, + 181, + 19, + 38, + 195, + 237, + 244, + 196, + 142, + 65, + 73, + 141, + 164, + 65, + 204, + 9, + 15 + ], + "plaintext": [ + 134, + 154, + 145, + 126, + 5, + 111, + 68, + 96, + 214, + 194, + 7, + 109, + 16 + ], + "ciphertext": [ + 204, + 135, + 140, + 143, + 118, + 9, + 97, + 228, + 173, + 8, + 173, + 9, + 165 + ], + "tag": [ + 195, + 3, + 201, + 104, + 11, + 103, + 60, + 4, + 158, + 155, + 123, + 236, + 140, + 40, + 66, + 139 + ] + }, + { + "key": [ + 229, + 177, + 231, + 169, + 78, + 158, + 31, + 218, + 8, + 115, + 87, + 30, + 236, + 113, + 52, + 41 + ], + "nonce": [ + 93, + 221, + 232, + 41, + 168, + 23, + 19, + 52, + 106, + 248, + 229, + 183 + ], + "aad": [ + 176, + 206, + 117, + 218, + 66, + 127, + 186, + 147, + 218, + 109, + 52, + 85, + 178, + 180, + 64, + 168, + 119, + 89, + 154, + 109, + 141, + 109, + 45, + 102, + 238, + 144, + 181, + 207, + 154, + 51, + 186, + 170, + 131, + 41, + 169, + 255, + 170, + 194, + 144, + 232, + 227, + 63, + 42, + 242, + 84, + 140, + 42, + 138, + 24, + 27, + 61, + 77, + 159, + 143, + 172, + 134, + 12, + 194, + 107, + 13, + 38, + 185, + 204, + 83, + 188, + 159, + 64, + 90, + 250, + 115, + 96, + 94, + 190, + 179, + 118, + 242, + 209, + 215, + 252, + 176, + 101, + 186, + 185, + 47, + 32, + 242, + 149, + 85, + 106, + 222 + ], + "plaintext": [ + 133, + 0, + 105, + 229, + 237, + 118, + 139, + 93, + 201, + 237, + 122, + 212, + 133 + ], + "ciphertext": [ + 194, + 17, + 217, + 7, + 157, + 85, + 98, + 101, + 157, + 176, + 30, + 23, + 209 + ], + "tag": [ + 136, + 72, + 147, + 251, + 3, + 93, + 61, + 114, + 55, + 212, + 124, + 54, + 61, + 230, + 43, + 179 + ] + }, + { + "key": [ + 27, + 150, + 168, + 105, + 159, + 132, + 5, + 133, + 145, + 242, + 133, + 144, + 165, + 230, + 60, + 14 + ], + "nonce": [ + 212, + 55, + 178, + 134, + 115, + 36, + 13, + 220, + 99, + 210, + 45, + 43 + ], + "aad": [ + 15, + 152, + 90, + 102, + 211, + 80, + 193, + 83, + 164, + 136, + 45, + 10, + 79, + 198, + 225, + 184, + 184, + 69, + 12, + 208, + 130, + 81, + 130, + 53, + 133, + 33, + 177, + 190, + 95, + 199, + 52, + 51, + 138, + 247, + 42, + 72, + 23, + 15, + 222, + 117, + 18, + 168, + 169, + 42, + 200, + 29, + 18, + 227, + 167, + 253, + 207, + 125, + 152, + 147, + 55, + 50, + 169, + 137, + 61, + 146, + 217, + 67, + 95, + 202, + 238, + 96, + 51, + 183, + 38, + 210, + 143, + 115, + 197, + 247, + 111, + 214, + 185, + 61, + 19, + 188, + 137, + 4, + 209, + 28, + 212, + 167, + 19, + 205, + 53, + 63 + ], + "plaintext": [ + 128, + 33, + 146, + 185, + 194, + 215, + 142, + 29, + 249, + 172, + 34, + 53, + 152 + ], + "ciphertext": [ + 140, + 19, + 205, + 237, + 97, + 208, + 140, + 31, + 45, + 184, + 120, + 55, + 142 + ], + "tag": [ + 67, + 238, + 135, + 124, + 18, + 29, + 74, + 50, + 158, + 129, + 229, + 29, + 104, + 169, + 216, + 69 + ] + }, + { + "key": [ + 148, + 135, + 75, + 111, + 55, + 56, + 217, + 99, + 87, + 117, + 83, + 161, + 145, + 85, + 244, + 250 + ], + "nonce": [ + 142, + 159, + 97, + 237, + 200, + 83, + 219, + 36, + 251, + 22, + 32, + 98 + ], + "aad": [ + 211, + 11, + 17, + 69, + 107, + 104, + 216, + 157, + 254, + 204, + 0, + 147, + 12, + 81, + 2, + 202, + 189, + 178, + 7, + 171, + 173, + 252, + 126, + 38, + 40, + 110, + 130, + 42, + 20, + 198, + 231, + 35, + 234, + 84, + 146, + 239, + 83, + 204, + 34, + 6, + 219, + 233, + 134, + 5, + 131, + 226, + 253, + 42, + 142, + 210, + 111, + 207, + 93, + 186, + 137, + 20, + 202, + 228, + 130, + 159, + 248, + 55, + 69, + 188, + 242, + 3, + 194, + 201, + 114, + 158, + 197, + 246, + 53, + 211, + 104, + 248, + 105, + 113, + 57, + 177, + 143, + 28, + 57, + 234, + 78, + 62, + 132, + 159, + 75, + 63 + ], + "plaintext": [ + 171, + 95, + 168, + 147, + 59, + 248, + 180, + 182, + 235, + 143, + 212, + 160, + 246 + ], + "ciphertext": [ + 227, + 89, + 69, + 154, + 249, + 65, + 132, + 147, + 221, + 138, + 244, + 109, + 39 + ], + "tag": [ + 77, + 217, + 79, + 59, + 18, + 143, + 52, + 221, + 212, + 3, + 104, + 134, + 250, + 8, + 69, + 6 + ] + }, + { + "key": [ + 116, + 52, + 228, + 236, + 10, + 162, + 106, + 168, + 159, + 122, + 2, + 91, + 124, + 171, + 238, + 107 + ], + "nonce": [ + 237, + 159, + 169, + 157, + 42, + 34, + 203, + 79, + 203, + 45, + 37, + 238 + ], + "aad": [ + 236, + 155, + 173, + 51, + 24, + 82, + 254, + 191, + 78, + 225, + 146, + 140, + 101, + 213, + 125, + 245, + 238, + 169, + 92, + 175, + 133, + 47, + 187, + 130, + 28, + 2, + 41, + 120, + 211, + 61, + 7, + 254, + 193, + 206, + 214, + 6, + 202, + 237, + 19, + 98, + 75, + 182, + 208, + 138, + 34, + 218, + 126, + 35, + 227, + 146, + 152, + 225, + 3, + 149, + 178, + 157, + 145, + 164, + 98, + 32, + 246, + 76, + 164, + 215, + 211, + 51, + 217, + 61, + 222, + 196, + 18, + 50, + 43, + 103, + 213, + 225, + 1, + 120, + 78, + 10, + 101, + 8, + 135, + 121, + 184, + 196, + 79, + 124, + 208, + 93 + ], + "plaintext": [ + 253, + 83, + 24, + 54, + 136, + 165, + 29, + 75, + 203, + 229, + 47, + 109, + 55 + ], + "ciphertext": [ + 151, + 247, + 76, + 214, + 255, + 46, + 167, + 212, + 50, + 98, + 254, + 111, + 25 + ], + "tag": [ + 126, + 213, + 188, + 240, + 206, + 4, + 72, + 250, + 102, + 29, + 12, + 15, + 188, + 211, + 101, + 120 + ] + }, + { + "key": [ + 114, + 165, + 101, + 211, + 179, + 182, + 129, + 75, + 234, + 55, + 219, + 127, + 101, + 155, + 161, + 210 + ], + "nonce": [ + 111, + 151, + 92, + 251, + 143, + 9, + 115, + 235, + 167, + 207, + 246, + 2 + ], + "aad": [ + 186, + 192, + 23, + 8, + 76, + 221, + 76, + 3, + 90, + 25, + 23, + 222, + 74, + 188, + 69, + 62, + 135, + 93, + 30, + 201, + 247, + 214, + 3, + 104, + 60, + 204, + 221, + 100, + 230, + 39, + 62, + 175, + 17, + 97, + 154, + 203, + 239, + 64, + 127, + 237, + 3, + 255, + 62, + 118, + 55, + 49, + 50, + 197, + 189, + 104, + 15, + 118, + 69, + 228, + 252, + 219, + 9, + 204, + 198, + 12, + 230, + 85, + 132, + 246, + 7, + 160, + 144, + 66, + 111, + 102, + 13, + 245, + 191, + 77, + 171, + 169, + 94, + 124, + 251, + 63, + 48, + 228, + 25, + 114, + 24, + 248, + 222, + 207, + 13, + 202 + ], + "plaintext": [ + 70, + 169, + 149, + 101, + 133, + 169, + 192, + 101, + 7, + 236, + 7, + 62, + 44 + ], + "ciphertext": [ + 166, + 87, + 72, + 45, + 18, + 55, + 120, + 70, + 235, + 227, + 202, + 111, + 102 + ], + "tag": [ + 15, + 16, + 150, + 78, + 119, + 107, + 37, + 174, + 7, + 155, + 53, + 126, + 25, + 156, + 140, + 208 + ] + }, + { + "key": [ + 168, + 90, + 142, + 15, + 22, + 199, + 175, + 158, + 127, + 50, + 200, + 23, + 97, + 26, + 2, + 73 + ], + "nonce": [ + 18, + 180, + 161, + 193, + 190, + 210, + 6, + 196, + 38, + 193, + 217, + 119 + ], + "aad": [ + 64, + 116, + 30, + 172, + 147, + 186, + 111, + 59, + 96, + 253, + 241, + 172, + 27, + 23, + 250, + 61, + 215, + 13, + 26, + 212, + 117, + 95, + 90, + 107, + 189, + 89, + 201, + 197, + 170, + 153, + 187, + 101, + 191, + 126, + 7, + 126, + 88, + 99, + 177, + 208, + 185, + 49, + 4, + 222, + 167, + 184, + 228, + 85, + 215, + 188, + 20, + 150, + 104, + 130, + 45, + 199, + 136, + 180, + 105, + 128, + 178, + 180, + 57, + 195, + 62, + 16, + 204, + 124, + 23, + 65, + 85, + 41, + 201, + 66, + 233, + 234, + 243, + 62, + 174, + 182, + 39, + 188, + 76, + 255, + 195, + 92, + 174, + 77, + 55, + 201 + ], + "plaintext": [ + 69, + 68, + 7, + 149, + 120, + 220, + 144, + 99, + 28, + 97, + 106, + 137, + 203 + ], + "ciphertext": [ + 176, + 190, + 149, + 22, + 107, + 245, + 87, + 186, + 230, + 21, + 43, + 54, + 11 + ], + "tag": [ + 70, + 57, + 31, + 53, + 215, + 57, + 1, + 115, + 42, + 123, + 156, + 126, + 185, + 118, + 174, + 217 + ] + }, + { + "key": [ + 150, + 200, + 55, + 202, + 82, + 148, + 68, + 109, + 56, + 154, + 111, + 6, + 203, + 66, + 231, + 55 + ], + "nonce": [ + 179, + 124, + 224, + 146, + 142, + 23, + 152, + 46, + 247, + 131, + 178, + 184 + ], + "aad": [ + 143, + 103, + 171, + 187, + 122, + 147, + 148, + 130, + 28, + 113, + 150, + 52, + 146, + 98, + 197, + 137, + 213, + 225, + 193, + 86, + 214, + 18, + 111, + 179, + 218, + 5, + 98, + 191, + 64, + 62, + 115, + 53, + 8, + 241, + 241, + 146, + 109, + 108, + 144, + 69, + 53, + 12, + 173, + 61, + 18, + 67, + 80, + 77, + 199, + 10, + 161, + 122, + 77, + 231, + 72, + 228, + 161, + 253, + 128, + 74, + 226, + 98, + 200, + 173, + 85, + 122, + 218, + 247, + 153, + 70, + 100, + 52, + 38, + 107, + 145, + 210, + 192, + 131, + 249, + 98, + 24, + 71, + 58, + 223, + 201, + 221, + 46, + 140, + 55, + 0 + ], + "plaintext": [ + 139, + 119, + 254, + 122, + 172, + 106, + 112, + 252, + 174, + 30, + 231, + 65, + 87 + ], + "ciphertext": [ + 217, + 80, + 171, + 134, + 49, + 166, + 108, + 49, + 61, + 104, + 1, + 151, + 125 + ], + "tag": [ + 49, + 225, + 9, + 117, + 60, + 187, + 101, + 30, + 209, + 148, + 54, + 159, + 0, + 132, + 3, + 35 + ] + }, + { + "key": [ + 250, + 214, + 153, + 254, + 45, + 251, + 138, + 43, + 149, + 87, + 8, + 255, + 151, + 177, + 88, + 146 + ], + "nonce": [ + 97, + 217, + 151, + 155, + 181, + 221, + 101, + 94, + 130, + 106, + 191, + 104 + ], + "aad": [ + 124, + 2, + 183, + 242, + 231, + 190, + 53, + 120, + 67, + 168, + 101, + 150, + 215, + 186, + 58, + 135, + 233, + 34, + 187, + 10, + 152, + 44, + 50, + 162, + 14, + 128, + 148, + 145, + 198, + 52, + 60, + 254, + 226, + 238, + 146, + 250, + 43, + 111, + 137, + 142, + 229, + 183, + 122, + 158, + 197, + 113, + 157, + 227, + 86, + 197, + 231, + 80, + 123, + 28, + 172, + 73, + 176, + 110, + 111, + 213, + 49, + 30, + 185, + 207, + 122, + 12, + 66, + 181, + 37, + 44, + 169, + 6, + 50, + 41, + 109, + 18, + 255, + 83, + 22, + 165, + 98, + 83, + 204, + 102, + 102, + 251, + 77, + 10, + 56, + 242 + ], + "plaintext": [ + 202, + 136, + 217, + 155, + 44, + 136, + 176, + 120, + 169, + 135, + 143, + 207, + 222 + ], + "ciphertext": [ + 191, + 162, + 134, + 50, + 61, + 73, + 4, + 222, + 140, + 210, + 19, + 137, + 192 + ], + "tag": [ + 207, + 58, + 248, + 13, + 246, + 189, + 229, + 149, + 214, + 181, + 162, + 141, + 107, + 113, + 18, + 241 + ] + }, + { + "key": [ + 202, + 131, + 161, + 16, + 156, + 245, + 191, + 183, + 210, + 77, + 107, + 167, + 44, + 108, + 26, + 116 + ], + "nonce": [ + 238, + 64, + 118, + 45, + 154, + 95, + 205, + 180, + 20, + 56, + 206, + 5 + ], + "aad": [ + 245, + 76, + 68, + 24, + 223, + 73, + 140, + 120, + 46, + 214, + 28, + 203, + 164, + 230, + 87, + 200, + 222, + 144, + 50, + 35, + 31, + 214, + 169, + 140, + 113, + 128, + 99, + 96, + 13, + 150, + 240, + 229, + 241, + 127, + 167, + 59, + 148, + 146, + 250, + 162, + 100, + 181, + 185, + 112, + 110, + 13, + 9, + 99, + 134, + 152, + 54, + 148, + 251, + 65, + 185, + 4, + 193, + 9, + 179, + 43, + 103, + 196, + 228, + 114, + 226, + 164, + 22, + 253, + 216, + 242, + 164, + 31, + 191, + 177, + 197, + 236, + 223, + 91, + 233, + 127, + 205, + 52, + 124, + 37, + 65, + 193, + 229, + 12, + 254, + 24 + ], + "plaintext": [ + 83, + 199, + 250, + 158, + 186, + 105, + 84, + 17, + 19, + 193, + 153, + 140, + 70 + ], + "ciphertext": [ + 140, + 237, + 214, + 20, + 154, + 32, + 59, + 235, + 71, + 215, + 132, + 137, + 255 + ], + "tag": [ + 0, + 144, + 104, + 23, + 120, + 85, + 57, + 48, + 109, + 7, + 119, + 94, + 33, + 91, + 251, + 75 + ] + }, + { + "key": [ + 101, + 164, + 103, + 213, + 232, + 213, + 3, + 160, + 145, + 110, + 92, + 202, + 175, + 36, + 11, + 32 + ], + "nonce": [ + 12, + 198, + 242, + 242, + 165, + 207, + 150, + 206, + 106, + 220, + 44, + 94 + ], + "aad": [ + 174, + 152, + 216, + 230, + 117, + 188, + 162, + 205, + 75, + 248, + 240, + 134, + 13, + 70, + 189, + 44, + 24, + 242, + 209, + 93, + 212, + 49, + 197, + 31, + 230, + 60, + 135, + 140, + 201, + 177, + 207, + 71, + 163, + 184, + 76, + 241, + 233, + 160, + 42, + 79, + 10, + 137, + 64, + 0, + 139, + 114, + 244, + 241, + 237, + 156, + 181, + 170, + 230, + 112, + 137, + 151, + 5, + 87, + 58, + 128, + 69, + 0, + 140, + 173, + 18, + 132, + 205, + 221, + 21, + 50, + 121, + 29, + 56, + 200, + 6, + 118, + 148, + 102, + 157, + 139, + 125, + 6, + 164, + 105, + 105, + 196, + 19, + 230, + 227, + 92 + ], + "plaintext": [ + 182, + 25, + 175, + 67, + 33, + 93, + 65, + 177, + 176, + 101, + 11, + 190, + 13 + ], + "ciphertext": [ + 108, + 36, + 189, + 14, + 204, + 151, + 135, + 63, + 15, + 124, + 136, + 2, + 197 + ], + "tag": [ + 3, + 22, + 138, + 6, + 180, + 149, + 243, + 243, + 29, + 70, + 240, + 222, + 135, + 213, + 71, + 26 + ] + }, + { + "key": [ + 76, + 243, + 40, + 225, + 242, + 241, + 128, + 194, + 221, + 158, + 109, + 112, + 60, + 174, + 24, + 143 + ], + "nonce": [ + 53, + 183, + 207, + 230, + 83, + 49, + 229, + 32, + 38, + 93, + 102, + 87 + ], + "aad": [ + 114, + 166, + 164, + 244, + 53, + 152, + 185, + 17, + 105, + 168, + 52, + 217, + 6, + 203, + 228, + 203, + 64, + 218, + 26, + 65, + 80, + 42, + 127, + 75, + 200, + 2, + 101, + 162, + 57, + 51, + 10, + 145, + 2, + 222, + 148, + 167, + 254, + 141, + 87, + 210, + 141, + 193, + 37, + 170, + 94, + 109, + 6, + 30, + 125, + 42, + 144, + 205, + 173, + 132, + 6, + 238, + 137, + 150, + 135, + 208, + 47, + 120, + 15, + 12, + 26, + 232, + 233, + 68, + 179, + 0, + 182, + 28, + 211, + 72, + 152, + 82, + 214, + 30, + 178, + 52, + 154, + 68, + 123, + 232, + 93, + 37, + 211, + 205, + 222, + 14 + ], + "plaintext": [ + 156, + 26, + 25, + 87, + 53, + 168, + 78, + 100, + 145, + 168, + 172, + 7, + 255 + ], + "ciphertext": [ + 235, + 77, + 56, + 194, + 59, + 233, + 116, + 69, + 194, + 94, + 139, + 242, + 244 + ], + "tag": [ + 176, + 5, + 244, + 36, + 247, + 122, + 129, + 244, + 169, + 101, + 170, + 122, + 27, + 248, + 207, + 229 + ] + }, + { + "key": [ + 125, + 98, + 177, + 106, + 85, + 28, + 18, + 172, + 33, + 2, + 71, + 36, + 146, + 164, + 211, + 175 + ], + "nonce": [ + 212, + 100, + 201, + 136, + 1, + 60, + 254, + 228, + 186, + 253, + 122, + 155 + ], + "aad": [ + 18, + 169, + 21, + 94, + 114, + 246, + 193, + 154, + 159, + 0, + 166, + 81, + 254, + 82, + 214, + 218, + 195, + 49, + 202, + 192, + 107, + 59, + 165, + 148, + 226, + 64, + 33, + 144, + 12, + 218, + 167, + 215, + 58, + 117, + 160, + 150, + 141, + 213, + 215, + 210, + 241, + 110, + 186, + 178, + 25, + 124, + 98, + 10, + 23, + 104, + 187, + 192, + 131, + 158, + 33, + 200, + 163, + 114, + 3, + 175, + 76, + 43, + 161, + 70, + 253, + 202, + 194, + 180, + 135, + 1, + 204, + 75, + 181, + 134, + 63, + 81, + 76, + 101, + 98, + 224, + 30, + 128, + 124, + 213, + 48, + 140, + 146, + 116, + 173, + 158 + ], + "plaintext": [ + 109, + 229, + 45, + 75, + 8, + 120, + 194, + 107, + 13, + 138, + 111, + 241, + 39 + ], + "ciphertext": [ + 166, + 221, + 66, + 183, + 82, + 202, + 203, + 71, + 241, + 222, + 154, + 218, + 161 + ], + "tag": [ + 198, + 71, + 46, + 114, + 42, + 57, + 174, + 68, + 190, + 94, + 66, + 66, + 204, + 88, + 224, + 70 + ] + }, + { + "key": [ + 239, + 108, + 133, + 250, + 73, + 9, + 25, + 211, + 66, + 115, + 67, + 87, + 254, + 54, + 86, + 189 + ], + "nonce": [ + 119, + 144, + 211, + 168, + 222, + 184, + 113, + 44, + 104, + 221, + 174, + 128 + ], + "aad": [ + 251, + 4, + 204, + 193, + 215, + 133, + 35, + 201, + 174, + 246, + 232, + 40, + 95, + 169, + 145, + 2, + 108, + 90, + 164, + 203, + 200, + 195, + 127, + 158, + 9, + 105, + 215, + 76, + 87, + 30, + 36, + 9, + 119, + 93, + 17, + 108, + 74, + 85, + 176, + 63, + 2, + 152, + 66, + 215, + 227, + 165, + 61, + 248, + 247, + 206, + 185, + 70, + 155, + 68, + 97, + 100, + 157, + 251, + 65, + 131, + 229, + 126, + 190, + 168, + 151, + 27, + 217, + 103, + 238, + 149, + 213, + 246, + 86, + 135, + 51, + 104, + 168, + 51, + 19, + 250, + 49, + 207, + 106, + 177, + 29, + 123, + 44, + 119, + 210, + 13 + ], + "plaintext": [ + 191, + 69, + 213, + 142, + 60, + 240, + 205, + 71, + 191, + 233, + 8, + 20, + 234 + ], + "ciphertext": [ + 124, + 241, + 175, + 166, + 13, + 52, + 40, + 200, + 253, + 37, + 217, + 71, + 155 + ], + "tag": [ + 99, + 227, + 165, + 238, + 188, + 215, + 36, + 104, + 232, + 255, + 171, + 85, + 227, + 202, + 239, + 231 + ] + }, + { + "key": [ + 172, + 91, + 74, + 208, + 156, + 115, + 237, + 11, + 128, + 147, + 27, + 146, + 12, + 235, + 15, + 173 + ], + "nonce": [ + 28, + 10, + 178, + 148, + 16, + 37, + 206, + 127, + 8, + 75, + 133, + 9 + ], + "aad": [ + 232, + 203, + 133, + 71, + 172, + 103, + 220, + 203, + 60, + 184, + 142, + 4, + 67, + 249, + 86, + 105, + 68, + 167, + 154, + 218, + 237, + 118, + 128, + 185, + 225, + 116, + 8, + 7, + 81, + 217, + 30, + 77, + 131, + 53, + 127, + 40, + 128, + 42, + 87, + 110, + 15, + 181, + 63, + 179, + 46, + 141, + 77, + 135, + 157, + 85, + 170, + 158, + 121, + 226, + 1, + 190, + 54, + 63, + 77, + 219, + 22, + 218, + 211, + 94, + 5, + 138, + 125, + 105, + 226, + 98, + 195, + 89, + 192, + 54, + 240, + 215, + 33, + 81, + 170, + 11, + 240, + 79, + 190, + 245, + 196, + 195, + 247, + 233, + 29, + 5 + ], + "plaintext": [ + 191, + 100, + 222, + 66, + 1, + 51, + 178, + 157, + 29, + 80, + 244, + 117, + 125 + ], + "ciphertext": [ + 55, + 97, + 246, + 17, + 236, + 63, + 248, + 83, + 201, + 21, + 230, + 30, + 246 + ], + "tag": [ + 191, + 144, + 108, + 61, + 171, + 215, + 133, + 150, + 139, + 165, + 199, + 171, + 212, + 161, + 236, + 235 + ] + }, + { + "key": [ + 53, + 129, + 140, + 147, + 197, + 74, + 50, + 31, + 44, + 204, + 40, + 233, + 103, + 210, + 44, + 225 + ], + "nonce": [ + 24, + 223, + 204, + 115, + 130, + 154, + 60, + 19, + 40, + 122, + 97, + 18 + ], + "aad": [ + 9, + 190, + 115, + 28, + 213, + 47, + 228, + 247, + 198, + 221, + 154, + 239, + 151, + 143, + 143, + 17, + 124, + 53, + 137, + 151, + 132, + 47, + 251, + 178, + 223, + 150, + 114, + 118, + 37, + 102, + 155, + 88, + 81, + 62, + 43, + 201, + 126, + 249, + 199, + 17, + 154, + 250, + 107, + 8, + 138, + 79, + 147, + 18, + 190, + 190, + 191, + 166, + 231, + 16, + 128, + 166, + 231, + 243, + 105, + 32, + 127, + 51, + 150, + 249, + 194, + 64, + 161, + 49, + 67, + 215, + 191, + 197, + 202, + 213, + 4, + 156, + 176, + 103, + 206, + 79, + 87, + 135, + 109, + 136, + 59, + 200, + 40, + 63, + 237, + 135 + ], + "plaintext": [ + 111, + 50, + 242, + 91, + 252, + 81, + 30, + 138, + 124, + 96, + 133, + 73, + 68 + ], + "ciphertext": [ + 149, + 83, + 235, + 3, + 120, + 34, + 159, + 219, + 33, + 63, + 212, + 96, + 2 + ], + "tag": [ + 236, + 34, + 142, + 192, + 252, + 39, + 59, + 103, + 217, + 34, + 194, + 186, + 61, + 222, + 91, + 223 + ] + }, + { + "key": [ + 153, + 113, + 7, + 16, + 89, + 171, + 192, + 9, + 228, + 242, + 189, + 105, + 134, + 157, + 179, + 56 + ], + "nonce": [ + 7, + 169, + 169, + 94, + 163, + 130, + 30, + 156, + 19, + 198, + 50, + 81 + ], + "aad": [], + "plaintext": [ + 245, + 75, + 195, + 80, + 31, + 237, + 79, + 111, + 109, + 251, + 94, + 168, + 1, + 6, + 223, + 11, + 216, + 54, + 230, + 130, + 98, + 37, + 183, + 92, + 2, + 34, + 246, + 232, + 89, + 179, + 89, + 131 + ], + "ciphertext": [ + 5, + 86, + 193, + 89, + 248, + 78, + 243, + 108, + 177, + 96, + 43, + 69, + 38, + 177, + 32, + 9, + 199, + 117, + 97, + 27, + 255, + 182, + 77, + 192, + 217, + 202, + 146, + 151, + 205, + 44, + 106, + 1 + ], + "tag": [ + 120, + 112, + 217, + 17, + 127, + 84, + 129, + 26, + 52, + 105, + 112, + 241, + 222, + 9, + 12, + 65 + ] + }, + { + "key": [ + 240, + 165, + 81, + 197, + 105, + 115, + 225, + 207, + 223, + 226, + 211, + 83, + 170, + 214, + 108, + 42 + ], + "nonce": [ + 148, + 233, + 94, + 5, + 68, + 171, + 11, + 11, + 153, + 151, + 174, + 227 + ], + "aad": [], + "plaintext": [ + 115, + 76, + 9, + 7, + 239, + 73, + 161, + 216, + 107, + 198, + 101, + 187, + 157, + 169, + 206, + 222, + 238, + 205, + 42, + 191, + 237, + 127, + 89, + 28, + 32, + 26, + 195, + 96, + 202, + 66, + 249, + 65 + ], + "ciphertext": [ + 242, + 194, + 240, + 195, + 94, + 11, + 246, + 197, + 245, + 194, + 77, + 138, + 173, + 186, + 25, + 237, + 53, + 132, + 137, + 89, + 185, + 197, + 134, + 96, + 76, + 57, + 100, + 40, + 73, + 52, + 24, + 208 + ], + "tag": [ + 136, + 85, + 174, + 203, + 233, + 96, + 74, + 131, + 159, + 165, + 212, + 129, + 248, + 118, + 15, + 252 + ] + }, + { + "key": [ + 198, + 53, + 119, + 95, + 161, + 65, + 106, + 190, + 55, + 92, + 121, + 46, + 167, + 164, + 134, + 172 + ], + "nonce": [ + 91, + 159, + 3, + 133, + 150, + 245, + 81, + 21, + 152, + 106, + 49, + 9 + ], + "aad": [], + "plaintext": [ + 84, + 23, + 33, + 86, + 252, + 178, + 196, + 3, + 146, + 0, + 152, + 7, + 189, + 62, + 196, + 161, + 28, + 44, + 27, + 109, + 105, + 173, + 32, + 199, + 115, + 223, + 61, + 158, + 124, + 243, + 94, + 61 + ], + "ciphertext": [ + 115, + 169, + 217, + 222, + 10, + 61, + 205, + 197, + 45, + 217, + 116, + 95, + 223, + 18, + 53, + 63, + 77, + 99, + 208, + 199, + 100, + 100, + 67, + 245, + 32, + 104, + 131, + 246, + 183, + 218, + 43, + 148 + ], + "tag": [ + 17, + 151, + 10, + 96, + 133, + 91, + 15, + 232, + 144, + 212, + 245, + 152, + 143, + 108, + 175, + 174 + ] + }, + { + "key": [ + 67, + 208, + 101, + 26, + 165, + 208, + 111, + 40, + 70, + 254, + 216, + 51, + 251, + 183, + 34, + 65 + ], + "nonce": [ + 42, + 230, + 38, + 119, + 43, + 115, + 199, + 205, + 37, + 218, + 176, + 20 + ], + "aad": [], + "plaintext": [ + 206, + 193, + 96, + 124, + 205, + 198, + 51, + 46, + 83, + 113, + 118, + 97, + 144, + 204, + 123, + 3, + 160, + 159, + 184, + 20, + 179, + 210, + 175, + 197, + 46, + 220, + 116, + 125, + 112, + 183, + 255, + 244 + ], + "ciphertext": [ + 234, + 116, + 44, + 196, + 26, + 250, + 197, + 255, + 191, + 168, + 30, + 137, + 186, + 216, + 47, + 31, + 138, + 7, + 236, + 162, + 129, + 252, + 37, + 59, + 83, + 60, + 193, + 87, + 236, + 238, + 196, + 224 + ], + "tag": [ + 219, + 30, + 25, + 251, + 84, + 90, + 226, + 24, + 244, + 173, + 60, + 154, + 109, + 166, + 73, + 151 + ] + }, + { + "key": [ + 222, + 250, + 47, + 14, + 186, + 101, + 23, + 153, + 198, + 4, + 30, + 111, + 40, + 160, + 219, + 59 + ], + "nonce": [ + 16, + 33, + 88, + 214, + 237, + 84, + 236, + 199, + 239, + 222, + 186, + 122 + ], + "aad": [], + "plaintext": [ + 103, + 132, + 69, + 119, + 161, + 152, + 180, + 86, + 250, + 65, + 10, + 252, + 237, + 232, + 252, + 36, + 251, + 151, + 4, + 89, + 9, + 110, + 186, + 224, + 59, + 254, + 29, + 211, + 42, + 107, + 150, + 101 + ], + "ciphertext": [ + 77, + 135, + 120, + 44, + 153, + 234, + 43, + 24, + 197, + 131, + 147, + 238, + 249, + 117, + 0, + 123, + 144, + 25, + 244, + 38, + 103, + 185, + 128, + 152, + 64, + 65, + 55, + 220, + 8, + 93, + 99, + 27 + ], + "tag": [ + 251, + 223, + 133, + 124, + 27, + 255, + 137, + 189, + 114, + 91, + 140, + 169, + 13, + 100, + 62, + 91 + ] + }, + { + "key": [ + 240, + 152, + 222, + 177, + 232, + 20, + 155, + 60, + 136, + 50, + 14, + 251, + 254, + 160, + 135, + 226 + ], + "nonce": [ + 129, + 70, + 57, + 62, + 208, + 221, + 9, + 216, + 157, + 26, + 231, + 229 + ], + "aad": [], + "plaintext": [ + 142, + 230, + 244, + 192, + 30, + 152, + 181, + 1, + 169, + 145, + 79, + 87, + 35, + 155, + 218, + 125, + 88, + 49, + 172, + 20, + 124, + 50, + 6, + 81, + 134, + 62, + 6, + 219, + 96, + 193, + 160, + 45 + ], + "ciphertext": [ + 18, + 35, + 9, + 171, + 148, + 201, + 137, + 1, + 16, + 75, + 218, + 4, + 136, + 239, + 181, + 99, + 149, + 157, + 166, + 73, + 121, + 101, + 62, + 228, + 248, + 230, + 88, + 163, + 234, + 138, + 60, + 156 + ], + "tag": [ + 147, + 227, + 217, + 61, + 5, + 128, + 197, + 86, + 126, + 207, + 172, + 39, + 77, + 162, + 17, + 226 + ] + }, + { + "key": [ + 99, + 178, + 138, + 236, + 143, + 125, + 212, + 74, + 242, + 105, + 228, + 142, + 53, + 41, + 74, + 52 + ], + "nonce": [ + 76, + 61, + 136, + 80, + 15, + 106, + 72, + 59, + 99, + 186, + 17, + 57 + ], + "aad": [], + "plaintext": [ + 91, + 134, + 235, + 113, + 139, + 57, + 23, + 83, + 125, + 78, + 245, + 27, + 108, + 116, + 168, + 92, + 201, + 169, + 0, + 2, + 65, + 13, + 143, + 52, + 108, + 190, + 86, + 200, + 106, + 199, + 45, + 77 + ], + "ciphertext": [ + 208, + 40, + 17, + 23, + 226, + 159, + 191, + 150, + 118, + 247, + 136, + 120, + 17, + 176, + 16, + 161, + 154, + 52, + 71, + 90, + 217, + 228, + 81, + 108, + 216, + 66, + 77, + 11, + 158, + 90, + 44, + 60 + ], + "tag": [ + 144, + 75, + 169, + 40, + 32, + 95, + 221, + 169, + 226, + 103, + 72, + 5, + 190, + 7, + 233, + 62 + ] + }, + { + "key": [ + 118, + 94, + 216, + 132, + 167, + 85, + 76, + 121, + 44, + 198, + 113, + 233, + 60, + 2, + 67, + 63 + ], + "nonce": [ + 102, + 116, + 103, + 177, + 104, + 219, + 86, + 173, + 244, + 138, + 38, + 226 + ], + "aad": [], + "plaintext": [ + 185, + 65, + 187, + 31, + 115, + 152, + 11, + 13, + 118, + 50, + 74, + 73, + 166, + 195, + 54, + 35, + 212, + 161, + 6, + 59, + 5, + 200, + 44, + 180, + 62, + 75, + 12, + 221, + 79, + 145, + 56, + 96 + ], + "ciphertext": [ + 132, + 144, + 110, + 120, + 172, + 121, + 223, + 103, + 160, + 251, + 76, + 207, + 76, + 141, + 164, + 57, + 9, + 67, + 57, + 173, + 201, + 45, + 152, + 171, + 190, + 3, + 44, + 223, + 79, + 93, + 146, + 236 + ], + "tag": [ + 117, + 10, + 137, + 168, + 66, + 166, + 221, + 125, + 19, + 23, + 245, + 97, + 185, + 3, + 132, + 2 + ] + }, + { + "key": [ + 129, + 110, + 215, + 237, + 173, + 202, + 158, + 143, + 162, + 178, + 185, + 249, + 235, + 209, + 77, + 81 + ], + "nonce": [ + 125, + 165, + 20, + 226, + 116, + 181, + 184, + 18, + 114, + 43, + 92, + 63 + ], + "aad": [], + "plaintext": [ + 199, + 105, + 8, + 35, + 73, + 84, + 255, + 147, + 155, + 162, + 41, + 63, + 161, + 172, + 101, + 74, + 75, + 238, + 65, + 165, + 116, + 242, + 105, + 77, + 9, + 9, + 128, + 72, + 26, + 8, + 8, + 63 + ], + "ciphertext": [ + 181, + 154, + 80, + 228, + 65, + 75, + 73, + 3, + 193, + 149, + 255, + 71, + 232, + 249, + 2, + 141, + 119, + 183, + 231, + 58, + 154, + 84, + 225, + 206, + 217, + 235, + 177, + 99, + 107, + 18, + 56, + 100 + ], + "tag": [ + 0, + 122, + 242, + 35, + 231, + 172, + 19, + 158, + 175, + 215, + 141, + 10, + 44, + 135, + 202, + 37 + ] + }, + { + "key": [ + 247, + 179, + 141, + 13, + 52, + 3, + 115, + 185, + 139, + 137, + 114, + 95, + 216, + 137, + 190, + 73 + ], + "nonce": [ + 188, + 43, + 135, + 168, + 131, + 175, + 28, + 11, + 255, + 131, + 136, + 251 + ], + "aad": [], + "plaintext": [ + 10, + 141, + 228, + 223, + 110, + 1, + 188, + 123, + 42, + 54, + 228, + 161, + 35, + 175, + 140, + 230, + 36, + 11, + 236, + 66, + 205, + 78, + 79, + 9, + 170, + 146, + 82, + 12, + 22, + 88, + 16, + 60 + ], + "ciphertext": [ + 101, + 238, + 8, + 171, + 117, + 27, + 239, + 55, + 32, + 219, + 49, + 52, + 145, + 252, + 162, + 10, + 135, + 205, + 253, + 107, + 139, + 2, + 143, + 83, + 191, + 53, + 35, + 4, + 218, + 80, + 73, + 17 + ], + "tag": [ + 171, + 188, + 129, + 202, + 113, + 143, + 203, + 198, + 167, + 92, + 133, + 173, + 167, + 78, + 70, + 111 + ] + }, + { + "key": [ + 220, + 102, + 44, + 119, + 162, + 213, + 32, + 160, + 103, + 203, + 214, + 189, + 126, + 17, + 150, + 150 + ], + "nonce": [ + 35, + 170, + 118, + 209, + 232, + 195, + 167, + 43, + 232, + 98, + 165, + 235 + ], + "aad": [], + "plaintext": [ + 95, + 182, + 110, + 20, + 77, + 37, + 100, + 224, + 150, + 131, + 32, + 101, + 100, + 125, + 174, + 118, + 134, + 89, + 214, + 220, + 209, + 10, + 29, + 190, + 0, + 133, + 140, + 228, + 245, + 20, + 137, + 18 + ], + "ciphertext": [ + 97, + 39, + 19, + 249, + 230, + 189, + 128, + 23, + 246, + 20, + 16, + 193, + 11, + 161, + 189, + 33, + 173, + 200, + 117, + 101, + 186, + 251, + 209, + 131, + 157, + 149, + 114, + 226, + 112, + 233, + 66, + 16 + ], + "tag": [ + 157, + 118, + 22, + 195, + 180, + 134, + 16, + 124, + 199, + 74, + 138, + 42, + 169, + 198, + 82, + 9 + ] + }, + { + "key": [ + 92, + 91, + 55, + 153, + 161, + 144, + 152, + 185, + 197, + 115, + 119, + 131, + 239, + 12, + 128, + 233 + ], + "nonce": [ + 52, + 251, + 158, + 16, + 25, + 21, + 99, + 157, + 239, + 48, + 244, + 14 + ], + "aad": [], + "plaintext": [ + 5, + 241, + 92, + 212, + 90, + 130, + 243, + 107, + 196, + 229, + 227, + 214, + 219, + 122, + 96, + 100, + 15, + 170, + 14, + 146, + 156, + 0, + 240, + 53, + 78, + 145, + 59, + 203, + 2, + 216, + 49, + 24 + ], + "ciphertext": [ + 173, + 96, + 245, + 61, + 81, + 182, + 176, + 15, + 195, + 54, + 106, + 75, + 75, + 193, + 107, + 103, + 142, + 205, + 18, + 71, + 62, + 139, + 213, + 92, + 54, + 59, + 192, + 217, + 74, + 132, + 75, + 112 + ], + "tag": [ + 26, + 82, + 131, + 152, + 238, + 44, + 159, + 67, + 103, + 67, + 209, + 160, + 134, + 2, + 197, + 180 + ] + }, + { + "key": [ + 58, + 84, + 19, + 23, + 25, + 138, + 47, + 177, + 185, + 4, + 112, + 233, + 13, + 109, + 127, + 56 + ], + "nonce": [ + 223, + 166, + 235, + 43, + 83, + 23, + 127, + 245, + 208, + 146, + 66, + 149 + ], + "aad": [], + "plaintext": [ + 58, + 193, + 138, + 244, + 109, + 63, + 177, + 93, + 71, + 123, + 132, + 159, + 225, + 234, + 208, + 135, + 132, + 7, + 66, + 203, + 216, + 178, + 236, + 49, + 180, + 91, + 138, + 194, + 228, + 165, + 57, + 117 + ], + "ciphertext": [ + 102, + 117, + 94, + 126, + 199, + 16, + 168, + 237, + 124, + 119, + 101, + 33, + 242, + 20, + 206, + 181, + 78, + 85, + 2, + 32, + 23, + 126, + 184, + 159, + 227, + 148, + 156, + 158, + 116, + 226, + 225, + 8 + ], + "tag": [ + 32, + 66, + 90, + 197, + 240, + 120, + 104, + 180, + 158, + 223, + 152, + 150, + 175, + 100, + 57, + 106 + ] + }, + { + "key": [ + 143, + 133, + 211, + 102, + 22, + 169, + 95, + 193, + 5, + 134, + 195, + 22, + 179, + 5, + 55, + 112 + ], + "nonce": [ + 211, + 32, + 181, + 0, + 38, + 150, + 9, + 172, + 225, + 190, + 103, + 206 + ], + "aad": [], + "plaintext": [ + 58, + 117, + 142, + 224, + 114, + 252, + 112, + 166, + 66, + 117, + 181, + 110, + 114, + 203, + 35, + 161, + 89, + 4, + 88, + 156, + 239, + 190, + 235, + 88, + 72, + 236, + 83, + 255, + 192, + 108, + 122, + 93 + ], + "ciphertext": [ + 251, + 47, + 227, + 235, + 64, + 237, + 251, + 210, + 42, + 81, + 107, + 236, + 53, + 157, + 75, + 180, + 35, + 138, + 7, + 0, + 164, + 111, + 238, + 17, + 54, + 160, + 97, + 133, + 64, + 34, + 156, + 65 + ], + "tag": [ + 66, + 38, + 147, + 22, + 206, + 206, + 125, + 136, + 44, + 198, + 140, + 62, + 217, + 210, + 240, + 174 + ] + }, + { + "key": [ + 95, + 226, + 101, + 12, + 5, + 152, + 217, + 24, + 228, + 155, + 179, + 62, + 60, + 49, + 213, + 180 + ], + "nonce": [ + 221, + 149, + 1, + 170, + 156, + 14, + 69, + 47, + 103, + 134, + 235, + 239 + ], + "aad": [], + "plaintext": [ + 90, + 107, + 96, + 236, + 10, + 194, + 63, + 109, + 99, + 255, + 43, + 25, + 25, + 186, + 99, + 130, + 146, + 126, + 246, + 222, + 105, + 58, + 133, + 95, + 62, + 62, + 253, + 73, + 189, + 68, + 83, + 216 + ], + "ciphertext": [ + 240, + 172, + 45, + 145, + 83, + 240, + 11, + 227, + 252, + 232, + 45, + 36, + 253, + 61, + 243, + 234, + 73, + 248, + 38, + 81, + 55, + 65, + 116, + 104, + 114, + 74, + 225, + 52, + 44, + 109, + 159, + 0 + ], + "tag": [ + 107, + 171, + 51, + 50, + 200, + 211, + 112, + 250, + 49, + 99, + 76, + 105, + 8, + 164, + 176, + 128 + ] + }, + { + "key": [ + 41, + 142, + 250, + 28, + 207, + 41, + 207, + 98, + 174, + 104, + 36, + 191, + 193, + 149, + 87, + 252 + ], + "nonce": [ + 111, + 88, + 169, + 63, + 225, + 210, + 7, + 250, + 228, + 237, + 47, + 109 + ], + "aad": [ + 2, + 31, + 175, + 210, + 56, + 70, + 57, + 115, + 255, + 232, + 2, + 86, + 229, + 177, + 198, + 177 + ], + "plaintext": [ + 204, + 56, + 188, + 205, + 107, + 197, + 54, + 173, + 145, + 155, + 19, + 149, + 245, + 214, + 56, + 1, + 249, + 159, + 128, + 104, + 214, + 92, + 165, + 172, + 99, + 135, + 45, + 175, + 22, + 185, + 57, + 1 + ], + "ciphertext": [ + 223, + 206, + 78, + 156, + 210, + 145, + 16, + 61, + 127, + 228, + 230, + 51, + 81, + 217, + 231, + 157, + 61, + 253, + 57, + 30, + 50, + 103, + 16, + 70, + 88, + 33, + 45, + 169, + 101, + 33, + 183, + 219 + ], + "tag": [ + 84, + 36, + 101, + 239, + 89, + 147, + 22, + 247, + 58, + 122, + 86, + 5, + 9, + 162, + 217, + 242 + ] + }, + { + "key": [ + 155, + 45, + 221, + 26, + 246, + 102, + 185, + 30, + 5, + 45, + 98, + 75, + 4, + 230, + 176, + 66 + ], + "nonce": [ + 78, + 225, + 46, + 98, + 137, + 156, + 97, + 249, + 82, + 10, + 19, + 193 + ], + "aad": [ + 229, + 145, + 230, + 238, + 9, + 73, + 129, + 176, + 227, + 131, + 66, + 154, + 49, + 204, + 234, + 170 + ], + "plaintext": [ + 1, + 229, + 220, + 135, + 162, + 66, + 120, + 44, + 163, + 21, + 106, + 39, + 68, + 111, + 56, + 107, + 217, + 160, + 96, + 255, + 239, + 31, + 99, + 195, + 188, + 17, + 169, + 60, + 227, + 5, + 23, + 93 + ], + "ciphertext": [ + 135, + 185, + 118, + 72, + 138, + 192, + 119, + 80, + 170, + 82, + 158, + 22, + 2, + 41, + 13, + 179, + 111, + 77, + 56, + 213, + 197, + 204, + 180, + 18, + 146, + 182, + 108, + 49, + 57, + 97, + 126, + 190 + ], + "tag": [ + 196, + 231, + 234, + 83, + 239, + 213, + 147, + 84, + 236, + 107, + 75, + 141, + 159, + 139, + 35, + 124 + ] + }, + { + "key": [ + 135, + 55, + 73, + 11, + 220, + 2, + 227, + 84, + 60, + 49, + 46, + 8, + 30, + 39, + 133, + 205 + ], + "nonce": [ + 207, + 52, + 96, + 184, + 1, + 13, + 65, + 15, + 213, + 82, + 71, + 32 + ], + "aad": [ + 235, + 168, + 193, + 202, + 73, + 233, + 119, + 207, + 38, + 235, + 82, + 50, + 94, + 89, + 175, + 168 + ], + "plaintext": [ + 170, + 10, + 203, + 191, + 43, + 132, + 121, + 16, + 213, + 110, + 228, + 218, + 138, + 159, + 64, + 151, + 63, + 133, + 214, + 204, + 225, + 214, + 50, + 106, + 119, + 126, + 255, + 1, + 23, + 62, + 102, + 208 + ], + "ciphertext": [ + 137, + 57, + 2, + 89, + 72, + 52, + 195, + 167, + 45, + 161, + 123, + 215, + 60, + 205, + 83, + 35, + 138, + 88, + 26, + 62, + 51, + 237, + 248, + 185, + 185, + 1, + 102, + 43, + 95, + 126, + 29, + 58 + ], + "tag": [ + 54, + 163, + 161, + 6, + 211, + 193, + 10, + 101, + 218, + 125, + 129, + 148, + 44, + 152, + 179, + 73 + ] + }, + { + "key": [ + 247, + 252, + 115, + 252, + 28, + 66, + 142, + 86, + 175, + 146, + 230, + 178, + 135, + 8, + 69, + 227 + ], + "nonce": [ + 55, + 91, + 26, + 132, + 254, + 250, + 170, + 128, + 127, + 254, + 186, + 24 + ], + "aad": [ + 13, + 102, + 137, + 1, + 22, + 58, + 8, + 163, + 56, + 196, + 39, + 52, + 45, + 49, + 231, + 153 + ], + "plaintext": [ + 248, + 113, + 169, + 166, + 149, + 183, + 79, + 149, + 1, + 148, + 47, + 153, + 163, + 72, + 157, + 75, + 239, + 236, + 103, + 104, + 215, + 193, + 125, + 28, + 56, + 245, + 31, + 214, + 205, + 22, + 173, + 196 + ], + "ciphertext": [ + 239, + 101, + 41, + 13, + 34, + 2, + 39, + 20, + 113, + 84, + 246, + 106, + 18, + 0, + 76, + 226, + 146, + 80, + 117, + 39, + 241, + 124, + 81, + 25, + 198, + 159, + 164, + 248, + 30, + 86, + 208, + 161 + ], + "tag": [ + 45, + 72, + 200, + 177, + 152, + 97, + 12, + 222, + 167, + 57, + 101, + 246, + 171, + 29, + 154, + 18 + ] + }, + { + "key": [ + 229, + 34, + 214, + 113, + 91, + 180, + 8, + 64, + 28, + 90, + 122, + 243, + 239, + 25, + 12, + 170 + ], + "nonce": [ + 26, + 59, + 42, + 49, + 52, + 24, + 237, + 38, + 222, + 141, + 223, + 87 + ], + "aad": [ + 185, + 147, + 235, + 25, + 62, + 157, + 89, + 56, + 41, + 25, + 235, + 188, + 158, + 58, + 216, + 41 + ], + "plaintext": [ + 211, + 241, + 2, + 51, + 80, + 95, + 82, + 79, + 251, + 141, + 150, + 29, + 131, + 33, + 190, + 136, + 201, + 117, + 112, + 75, + 221, + 157, + 249, + 88, + 243, + 121, + 90, + 223, + 0, + 133, + 170, + 167 + ], + "ciphertext": [ + 225, + 81, + 145, + 86, + 204, + 39, + 144, + 91, + 141, + 162, + 77, + 41, + 251, + 80, + 45, + 84, + 4, + 46, + 182, + 250, + 177, + 12, + 95, + 106, + 153, + 209, + 239, + 84, + 201, + 44, + 85, + 93 + ], + "tag": [ + 127, + 208, + 79, + 99, + 123, + 116, + 141, + 177, + 125, + 167, + 238, + 52, + 9, + 154, + 17, + 42 + ] + }, + { + "key": [ + 85, + 25, + 13, + 225, + 60, + 251, + 190, + 223, + 74, + 7, + 135, + 249, + 236, + 195, + 78, + 69 + ], + "nonce": [ + 135, + 128, + 59, + 207, + 106, + 105, + 150, + 42, + 186, + 233, + 41, + 229 + ], + "aad": [ + 6, + 124, + 56, + 87, + 204, + 36, + 12, + 107, + 181, + 246, + 40, + 188, + 199, + 207, + 85, + 89 + ], + "plaintext": [ + 238, + 93, + 160, + 2, + 108, + 225, + 3, + 20, + 8, + 115, + 34, + 97, + 73, + 183, + 95, + 167, + 52, + 136, + 139, + 0, + 81, + 138, + 234, + 192, + 34, + 68, + 102, + 187, + 176, + 210, + 61, + 12 + ], + "ciphertext": [ + 6, + 54, + 45, + 35, + 110, + 150, + 24, + 3, + 125, + 49, + 212, + 241, + 234, + 13, + 246, + 6, + 78, + 11, + 240, + 107, + 108, + 89, + 4, + 83, + 14, + 16, + 2, + 232, + 71, + 156, + 22, + 251 + ], + "tag": [ + 52, + 42, + 39, + 174, + 160, + 239, + 10, + 162, + 106, + 217, + 46, + 163, + 169, + 42, + 250, + 55 + ] + }, + { + "key": [ + 101, + 247, + 165, + 255, + 127, + 234, + 168, + 213, + 7, + 54, + 220, + 227, + 200, + 82, + 76, + 249 + ], + "nonce": [ + 223, + 160, + 130, + 32, + 101, + 177, + 237, + 73, + 135, + 104, + 82, + 23 + ], + "aad": [ + 204, + 79, + 212, + 216, + 37, + 132, + 5, + 155, + 90, + 22, + 93, + 99, + 45, + 86, + 254, + 30 + ], + "plaintext": [ + 163, + 45, + 58, + 237, + 19, + 113, + 207, + 205, + 223, + 94, + 115, + 90, + 157, + 149, + 185, + 109, + 26, + 197, + 156, + 58, + 183, + 132, + 190, + 131, + 100, + 204, + 28, + 243, + 183, + 27, + 247, + 14 + ], + "ciphertext": [ + 189, + 243, + 86, + 165, + 74, + 92, + 250, + 40, + 30, + 219, + 231, + 227, + 89, + 102, + 181, + 184, + 166, + 136, + 148, + 242, + 130, + 205, + 122, + 115, + 77, + 80, + 45, + 254, + 230, + 220, + 177, + 245 + ], + "tag": [ + 79, + 240, + 91, + 40, + 152, + 223, + 110, + 220, + 39, + 87, + 74, + 46, + 179, + 149, + 255, + 200 + ] + }, + { + "key": [ + 223, + 12, + 235, + 115, + 223, + 189, + 6, + 120, + 47, + 105, + 205, + 81, + 204, + 79, + 193, + 251 + ], + "nonce": [ + 197, + 251, + 75, + 240, + 180, + 4, + 119, + 225, + 14, + 93, + 21, + 212 + ], + "aad": [ + 242, + 146, + 196, + 194, + 162, + 53, + 110, + 112, + 254, + 176, + 0, + 58, + 40, + 112, + 142, + 216 + ], + "plaintext": [ + 250, + 157, + 163, + 93, + 141, + 129, + 37, + 133, + 50, + 47, + 161, + 192, + 207, + 70, + 51, + 176, + 100, + 36, + 39, + 44, + 250, + 193, + 197, + 165, + 17, + 56, + 176, + 185, + 185, + 29, + 68, + 61 + ], + "ciphertext": [ + 232, + 28, + 208, + 10, + 150, + 220, + 183, + 25, + 252, + 44, + 58, + 247, + 181, + 66, + 12, + 181, + 102, + 127, + 237, + 83, + 175, + 143, + 86, + 29, + 194, + 22, + 252, + 114, + 21, + 171, + 22, + 161 + ], + "tag": [ + 96, + 132, + 129, + 22, + 112, + 107, + 229, + 91, + 78, + 169, + 57, + 186, + 137, + 158, + 178, + 183 + ] + }, + { + "key": [ + 114, + 32, + 94, + 101, + 31, + 3, + 226, + 193, + 110, + 234, + 118, + 137, + 175, + 67, + 188, + 74 + ], + "nonce": [ + 66, + 196, + 123, + 47, + 149, + 176, + 236, + 2, + 101, + 47, + 31, + 255 + ], + "aad": [ + 127, + 151, + 143, + 193, + 241, + 178, + 249, + 243, + 123, + 136, + 185, + 107, + 140, + 20, + 235, + 236 + ], + "plaintext": [ + 127, + 190, + 120, + 22, + 80, + 195, + 150, + 202, + 140, + 220, + 107, + 46, + 253, + 218, + 224, + 0, + 124, + 176, + 8, + 196, + 252, + 115, + 16, + 250, + 23, + 236, + 90, + 224, + 96, + 23, + 19, + 145 + ], + "ciphertext": [ + 179, + 243, + 168, + 191, + 226, + 144, + 106, + 193, + 187, + 201, + 61, + 220, + 112, + 26, + 85, + 41, + 194, + 203, + 21, + 99, + 84, + 206, + 223, + 133, + 146, + 143, + 96, + 94, + 214, + 0, + 91, + 220 + ], + "tag": [ + 145, + 81, + 200, + 0, + 13, + 194, + 94, + 186, + 74, + 87, + 144, + 139, + 35, + 138, + 251, + 33 + ] + }, + { + "key": [ + 162, + 201, + 108, + 11, + 5, + 28, + 99, + 62, + 193, + 11, + 47, + 204, + 180, + 63, + 69, + 23 + ], + "nonce": [ + 196, + 193, + 63, + 201, + 241, + 95, + 72, + 43, + 246, + 189, + 141, + 11 + ], + "aad": [ + 148, + 175, + 199, + 74, + 112, + 64, + 196, + 119, + 5, + 114, + 38, + 39, + 224, + 95, + 21, + 156 + ], + "plaintext": [ + 95, + 10, + 80, + 217, + 118, + 235, + 32, + 72, + 188, + 72, + 29, + 123, + 202, + 155, + 62, + 115, + 103, + 195, + 177, + 44, + 158, + 152, + 172, + 133, + 33, + 244, + 92, + 113, + 90, + 227, + 191, + 255 + ], + "ciphertext": [ + 43, + 222, + 34, + 92, + 166, + 59, + 64, + 206, + 100, + 80, + 12, + 64, + 192, + 15, + 165, + 197, + 0, + 134, + 196, + 49, + 233, + 93, + 31, + 153, + 103, + 140, + 185, + 169, + 11, + 218, + 37, + 2 + ], + "tag": [ + 106, + 41, + 106, + 164, + 126, + 82, + 115, + 115, + 4, + 234, + 175, + 236, + 12, + 61, + 12, + 101 + ] + }, + { + "key": [ + 16, + 129, + 70, + 222, + 20, + 139, + 212, + 219, + 166, + 156, + 74, + 210, + 193, + 26, + 53, + 192 + ], + "nonce": [ + 157, + 251, + 226, + 250, + 70, + 164, + 108, + 62, + 186, + 243, + 28, + 72 + ], + "aad": [ + 188, + 131, + 128, + 143, + 158, + 136, + 73, + 103, + 200, + 77, + 40, + 206, + 152, + 29, + 253, + 27 + ], + "plaintext": [ + 1, + 4, + 195, + 218, + 76, + 190, + 80, + 243, + 28, + 207, + 204, + 66, + 109, + 99, + 77, + 141, + 57, + 104, + 100, + 68, + 163, + 183, + 91, + 251, + 84, + 214, + 115, + 73, + 251, + 126, + 112, + 23 + ], + "ciphertext": [ + 63, + 68, + 36, + 145, + 45, + 250, + 175, + 216, + 248, + 176, + 139, + 167, + 186, + 234, + 149, + 239, + 251, + 62, + 69, + 113, + 114, + 10, + 38, + 38, + 185, + 42, + 216, + 247, + 166, + 157, + 68, + 119 + ], + "tag": [ + 238, + 222, + 200, + 94, + 217, + 225, + 74, + 95, + 204, + 44, + 208, + 206, + 80, + 255, + 0, + 164 + ] + }, + { + "key": [ + 55, + 185, + 53, + 36, + 68, + 188, + 170, + 150, + 36, + 178, + 103, + 86, + 106, + 89, + 9, + 90 + ], + "nonce": [ + 215, + 167, + 36, + 115, + 185, + 155, + 40, + 144, + 239, + 124, + 73, + 40 + ], + "aad": [ + 247, + 117, + 26, + 242, + 220, + 191, + 90, + 126, + 184, + 29, + 107, + 215, + 60, + 237, + 18, + 32 + ], + "plaintext": [ + 147, + 3, + 123, + 43, + 72, + 20, + 84, + 31, + 66, + 94, + 160, + 188, + 200, + 140, + 225, + 72, + 102, + 50, + 145, + 156, + 239, + 68, + 58, + 83, + 116, + 217, + 148, + 78, + 220, + 126, + 66, + 237 + ], + "ciphertext": [ + 73, + 30, + 8, + 147, + 166, + 82, + 165, + 151, + 93, + 61, + 183, + 40, + 104, + 181, + 97, + 147, + 17, + 169, + 205, + 218, + 209, + 28, + 85, + 34, + 233, + 88, + 147, + 196, + 46, + 59, + 99, + 169 + ], + "tag": [ + 252, + 216, + 18, + 5, + 18, + 235, + 63, + 20, + 41, + 94, + 253, + 59, + 4, + 91, + 8, + 104 + ] + }, + { + "key": [ + 221, + 19, + 50, + 241, + 126, + 98, + 178, + 190, + 136, + 158, + 154, + 57, + 159, + 176, + 211, + 254 + ], + "nonce": [ + 63, + 0, + 40, + 203, + 124, + 184, + 241, + 9, + 26, + 78, + 47, + 74 + ], + "aad": [ + 47, + 51, + 197, + 248, + 95, + 151, + 104, + 17, + 239, + 103, + 83, + 63, + 72, + 137, + 23, + 250 + ], + "plaintext": [ + 156, + 46, + 7, + 104, + 60, + 108, + 160, + 109, + 1, + 39, + 8, + 173, + 109, + 174, + 149, + 8, + 46, + 235, + 211, + 98, + 97, + 204, + 200, + 116, + 34, + 106, + 211, + 84, + 204, + 139, + 168, + 46 + ], + "ciphertext": [ + 164, + 250, + 147, + 17, + 227, + 192, + 44, + 59, + 6, + 138, + 63, + 17, + 174, + 118, + 87, + 239, + 195, + 163, + 230, + 153, + 145, + 37, + 18, + 128, + 80, + 57, + 64, + 172, + 74, + 126, + 137, + 80 + ], + "tag": [ + 14, + 94, + 119, + 186, + 160, + 243, + 109, + 177, + 28, + 197, + 191, + 194, + 127, + 252, + 122, + 73 + ] + }, + { + "key": [ + 57, + 226, + 21, + 241, + 162, + 87, + 34, + 87, + 239, + 217, + 57, + 172, + 3, + 101, + 236, + 151 + ], + "nonce": [ + 225, + 244, + 218, + 113, + 44, + 76, + 30, + 179, + 16, + 39, + 53, + 44 + ], + "aad": [ + 147, + 104, + 232, + 213, + 37, + 231, + 119, + 7, + 211, + 22, + 84, + 45, + 205, + 115, + 92, + 110 + ], + "plaintext": [ + 33, + 247, + 214, + 43, + 178, + 145, + 141, + 222, + 106, + 207, + 155, + 108, + 155, + 122, + 254, + 212, + 190, + 125, + 98, + 60, + 62, + 32, + 112, + 68, + 75, + 8, + 127, + 180, + 13, + 231, + 230, + 241 + ], + "ciphertext": [ + 60, + 147, + 235, + 141, + 240, + 5, + 86, + 227, + 244, + 45, + 84, + 172, + 253, + 99, + 95, + 191, + 252, + 15, + 119, + 248, + 104, + 166, + 143, + 115, + 142, + 194, + 145, + 130, + 19, + 186, + 154, + 34 + ], + "tag": [ + 13, + 216, + 53, + 45, + 80, + 126, + 82, + 83, + 238, + 8, + 73, + 104, + 141, + 46, + 232, + 109 + ] + }, + { + "key": [ + 6, + 243, + 111, + 73, + 57, + 71, + 59, + 84, + 14, + 113, + 219, + 53, + 243, + 152, + 165, + 61 + ], + "nonce": [ + 19, + 239, + 226, + 17, + 203, + 110, + 243, + 163, + 116, + 244, + 218, + 133 + ], + "aad": [ + 140, + 190, + 62, + 62, + 177, + 152, + 24, + 219, + 25, + 121, + 1, + 189, + 78, + 228, + 45, + 226 + ], + "plaintext": [ + 165, + 170, + 254, + 220, + 76, + 29, + 219, + 127, + 107, + 56, + 247, + 151, + 77, + 22, + 161, + 200, + 140, + 247, + 239, + 30, + 190, + 80, + 39, + 234, + 79, + 181, + 93, + 177, + 97, + 1, + 252, + 32 + ], + "ciphertext": [ + 125, + 33, + 251, + 6, + 0, + 45, + 25, + 244, + 7, + 65, + 178, + 117, + 183, + 44, + 219, + 171, + 190, + 3, + 36, + 96, + 236, + 241, + 61, + 152, + 241, + 202, + 252, + 179, + 15, + 112, + 74, + 240 + ], + "tag": [ + 221, + 75, + 236, + 161, + 103, + 12, + 244, + 55, + 55, + 42, + 186, + 119, + 188, + 62, + 146, + 97 + ] + }, + { + "key": [ + 254, + 220, + 113, + 85, + 25, + 45, + 0, + 178, + 60, + 221, + 152, + 117, + 13, + 185, + 235, + 186 + ], + "nonce": [ + 167, + 107, + 116, + 245, + 92, + 26, + 23, + 86, + 160, + 131, + 56, + 177 + ], + "aad": [ + 42, + 210, + 6, + 196, + 23, + 110, + 126, + 85, + 42, + 160, + 136, + 54, + 136, + 104, + 22, + 250, + 250, + 119, + 231, + 89 + ], + "plaintext": [ + 104, + 49, + 67, + 91, + 136, + 87, + 218, + 241, + 197, + 19, + 177, + 72, + 130, + 13, + 19, + 181, + 167, + 44, + 196, + 144, + 189, + 167, + 154, + 152, + 166, + 245, + 32, + 216, + 118, + 60, + 57, + 209 + ], + "ciphertext": [ + 21, + 130, + 56, + 5, + 218, + 137, + 161, + 146, + 59, + 252, + 29, + 111, + 135, + 120, + 77, + 86, + 186, + 209, + 18, + 139, + 77, + 255, + 219, + 222, + 239, + 187, + 47, + 165, + 98, + 195, + 94, + 104 + ], + "tag": [ + 210, + 61, + 196, + 85, + 206, + 212, + 152, + 135, + 199, + 23, + 232, + 234, + 190, + 236, + 41, + 132 + ] + }, + { + "key": [ + 139, + 222, + 196, + 88, + 167, + 51, + 197, + 44, + 217, + 148, + 183, + 194, + 163, + 121, + 71, + 217 + ], + "nonce": [ + 191, + 141, + 149, + 77, + 245, + 241, + 238, + 81, + 252, + 63, + 24, + 144 + ], + "aad": [ + 255, + 226, + 104, + 116, + 165, + 75, + 211, + 138, + 2, + 108, + 92, + 114, + 158, + 40, + 82, + 167, + 72, + 69, + 116, + 18 + ], + "plaintext": [ + 157, + 95, + 28, + 144, + 93, + 249, + 0, + 17, + 31, + 32, + 82, + 166, + 9, + 19, + 216, + 169, + 216, + 60, + 212, + 14, + 67, + 186, + 136, + 32, + 59, + 5, + 227, + 219, + 240, + 227, + 127, + 190 + ], + "ciphertext": [ + 240, + 86, + 207, + 142, + 166, + 196, + 243, + 83, + 240, + 141, + 84, + 194, + 122, + 142, + 243, + 50, + 74, + 185, + 39, + 166, + 65, + 86, + 63, + 159, + 93, + 197, + 240, + 44, + 59, + 34, + 4, + 177 + ], + "tag": [ + 47, + 139, + 147, + 81, + 66, + 99, + 99, + 240, + 159, + 93, + 23, + 246, + 52, + 163, + 129, + 169 + ] + }, + { + "key": [ + 10, + 101, + 31, + 149, + 182, + 254, + 93, + 148, + 66, + 253, + 49, + 28, + 238, + 36, + 82, + 41 + ], + "nonce": [ + 183, + 178, + 52, + 155, + 96, + 172, + 92, + 240, + 152, + 133, + 239, + 78 + ], + "aad": [ + 114, + 90, + 8, + 154, + 55, + 186, + 80, + 229, + 49, + 67, + 114, + 33, + 64, + 206, + 92, + 55, + 188, + 10, + 72, + 231 + ], + "plaintext": [ + 28, + 215, + 190, + 118, + 17, + 216, + 247, + 201, + 215, + 95, + 223, + 63, + 83, + 210, + 129, + 114, + 174, + 77, + 70, + 44, + 6, + 218, + 86, + 203, + 56, + 102, + 135, + 242, + 192, + 152, + 226, + 139 + ], + "ciphertext": [ + 226, + 146, + 111, + 52, + 195, + 8, + 131, + 163, + 183, + 235, + 13, + 196, + 118, + 39, + 170, + 208, + 144, + 17, + 22, + 84, + 164, + 152, + 15, + 196, + 252, + 149, + 47, + 231, + 167, + 182, + 182, + 10 + ], + "tag": [ + 97, + 115, + 69, + 218, + 184, + 151, + 60, + 33, + 173, + 113, + 28, + 42, + 81, + 136, + 95, + 131 + ] + }, + { + "key": [ + 254, + 194, + 69, + 45, + 8, + 131, + 165, + 76, + 14, + 51, + 252, + 204, + 9, + 45, + 220, + 246 + ], + "nonce": [ + 158, + 62, + 53, + 77, + 48, + 194, + 199, + 124, + 208, + 217, + 160, + 254 + ], + "aad": [ + 108, + 18, + 177, + 18, + 17, + 14, + 191, + 54, + 147, + 9, + 16, + 241, + 191, + 201, + 237, + 73, + 225, + 68, + 64, + 177 + ], + "plaintext": [ + 149, + 185, + 197, + 230, + 173, + 183, + 252, + 206, + 33, + 42, + 191, + 83, + 80, + 149, + 189, + 149, + 92, + 58, + 160, + 247, + 172, + 36, + 40, + 132, + 31, + 77, + 233, + 3, + 82, + 99, + 68, + 106 + ], + "ciphertext": [ + 168, + 87, + 84, + 244, + 81, + 180, + 15, + 58, + 181, + 118, + 50, + 123, + 75, + 153, + 250, + 9, + 173, + 201, + 83, + 128, + 41, + 159, + 97, + 197, + 199, + 168, + 226, + 129, + 136, + 210, + 164, + 11 + ], + "tag": [ + 148, + 185, + 121, + 247, + 113, + 142, + 193, + 52, + 18, + 224, + 63, + 52, + 97, + 68, + 1, + 0 + ] + }, + { + "key": [ + 229, + 246, + 217, + 242, + 200, + 173, + 8, + 161, + 80, + 1, + 87, + 224, + 39, + 185, + 34, + 25 + ], + "nonce": [ + 148, + 53, + 142, + 235, + 104, + 41, + 241, + 190, + 77, + 227, + 171, + 252 + ], + "aad": [ + 179, + 184, + 96, + 146, + 156, + 220, + 63, + 176, + 227, + 147, + 242, + 18, + 135, + 243, + 221, + 220, + 74, + 28, + 146, + 122 + ], + "plaintext": [ + 50, + 4, + 133, + 96, + 64, + 237, + 217, + 64, + 26, + 137, + 7, + 105, + 135, + 92, + 194, + 82, + 229, + 220, + 180, + 167, + 126, + 149, + 30, + 110, + 174, + 246, + 215, + 49, + 138, + 6, + 188, + 244 + ], + "ciphertext": [ + 177, + 186, + 81, + 74, + 228, + 196, + 18, + 112, + 215, + 190, + 175, + 170, + 27, + 172, + 47, + 169, + 147, + 207, + 90, + 243, + 96, + 122, + 0, + 140, + 107, + 180, + 174, + 226, + 161, + 33, + 45, + 212 + ], + "tag": [ + 126, + 15, + 90, + 164, + 5, + 83, + 18, + 143, + 44, + 21, + 203, + 149, + 103, + 201, + 80, + 225 + ] + }, + { + "key": [ + 174, + 204, + 252, + 101, + 6, + 60, + 63, + 204, + 252, + 90, + 11, + 41, + 25, + 61, + 30, + 244 + ], + "nonce": [ + 112, + 100, + 156, + 157, + 40, + 72, + 210, + 28, + 87, + 93, + 105, + 20 + ], + "aad": [ + 99, + 125, + 195, + 146, + 207, + 227, + 168, + 226, + 254, + 94, + 135, + 23, + 153, + 164, + 109, + 190, + 56, + 245, + 150, + 16 + ], + "plaintext": [ + 70, + 172, + 55, + 93, + 165, + 101, + 39, + 195, + 198, + 253, + 95, + 40, + 243, + 60, + 99, + 177, + 255, + 175, + 6, + 195, + 59, + 143, + 50, + 158, + 174, + 55, + 248, + 87, + 154, + 98, + 41, + 27 + ], + "ciphertext": [ + 127, + 136, + 65, + 211, + 200, + 41, + 7, + 89, + 108, + 74, + 166, + 237, + 67, + 59, + 158, + 179, + 59, + 36, + 214, + 111, + 10, + 12, + 221, + 132, + 109, + 94, + 165, + 22, + 104, + 151, + 93, + 157 + ], + "tag": [ + 223, + 186, + 183, + 164, + 45, + 96, + 205, + 167, + 59, + 3, + 24, + 144, + 52, + 228, + 79, + 245 + ] + }, + { + "key": [ + 29, + 186, + 240, + 189, + 217, + 116, + 180, + 138, + 227, + 115, + 246, + 134, + 169, + 97, + 174, + 186 + ], + "nonce": [ + 163, + 166, + 69, + 77, + 23, + 172, + 98, + 34, + 72, + 174, + 152, + 87 + ], + "aad": [ + 57, + 56, + 67, + 54, + 12, + 56, + 138, + 110, + 47, + 131, + 199, + 32, + 46, + 141, + 166, + 250, + 112, + 65, + 166, + 190 + ], + "plaintext": [ + 131, + 161, + 49, + 247, + 115, + 123, + 78, + 136, + 31, + 178, + 85, + 171, + 146, + 37, + 247, + 250, + 186, + 150, + 71, + 102, + 38, + 237, + 39, + 22, + 141, + 99, + 66, + 204, + 202, + 141, + 62, + 117 + ], + "ciphertext": [ + 36, + 113, + 210, + 57, + 87, + 214, + 48, + 90, + 134, + 82, + 11, + 117, + 124, + 84, + 137, + 10, + 87, + 246, + 101, + 164, + 74, + 25, + 175, + 47, + 141, + 85, + 230, + 131, + 54, + 89, + 231, + 48 + ], + "tag": [ + 70, + 147, + 177, + 12, + 137, + 152, + 88, + 14, + 152, + 107, + 224, + 187, + 38, + 162, + 46, + 63 + ] + }, + { + "key": [ + 84, + 15, + 64, + 254, + 138, + 194, + 229, + 6, + 182, + 155, + 178, + 186, + 53, + 111, + 248, + 219 + ], + "nonce": [ + 5, + 2, + 229, + 26, + 196, + 47, + 100, + 29, + 122, + 1, + 118, + 176 + ], + "aad": [ + 155, + 31, + 43, + 47, + 215, + 38, + 87, + 146, + 133, + 38, + 40, + 223, + 146, + 106, + 188, + 86, + 9, + 170, + 167, + 98 + ], + "plaintext": [ + 145, + 10, + 0, + 12, + 94, + 153, + 36, + 88, + 112, + 240, + 141, + 214, + 88, + 182, + 72, + 249, + 68, + 208, + 68, + 38, + 167, + 13, + 109, + 70, + 216, + 232, + 142, + 200, + 237, + 223, + 179, + 36 + ], + "ciphertext": [ + 147, + 129, + 212, + 183, + 45, + 116, + 11, + 88, + 195, + 242, + 127, + 141, + 255, + 1, + 216, + 190, + 244, + 94, + 118, + 155, + 131, + 69, + 57, + 164, + 57, + 23, + 60, + 136, + 166, + 209, + 142, + 98 + ], + "tag": [ + 124, + 103, + 136, + 147, + 161, + 34, + 165, + 15, + 119, + 125, + 252, + 235, + 245, + 20, + 248, + 29 + ] + }, + { + "key": [ + 85, + 208, + 224, + 86, + 10, + 32, + 39, + 187, + 135, + 61, + 132, + 163, + 159, + 248, + 112, + 70 + ], + "nonce": [ + 97, + 109, + 97, + 186, + 148, + 33, + 108, + 156, + 124, + 9, + 3, + 176 + ], + "aad": [ + 160, + 32, + 62, + 31, + 49, + 246, + 107, + 253, + 200, + 25, + 208, + 134, + 164, + 139, + 112, + 93, + 30, + 183, + 114, + 27 + ], + "plaintext": [ + 22, + 16, + 67, + 23, + 119, + 192, + 17, + 54, + 192, + 160, + 7, + 63, + 92, + 17, + 76, + 53, + 127, + 2, + 22, + 213, + 234, + 163, + 28, + 212, + 11, + 140, + 214, + 5, + 172, + 86, + 223, + 171 + ], + "ciphertext": [ + 93, + 132, + 106, + 141, + 254, + 2, + 207, + 36, + 84, + 225, + 16, + 117, + 162, + 54, + 178, + 166, + 172, + 197, + 152, + 25, + 233, + 202, + 106, + 245, + 128, + 105, + 6, + 100, + 193, + 149, + 237, + 211 + ], + "tag": [ + 36, + 205, + 13, + 217, + 80, + 133, + 154, + 185, + 209, + 174, + 101, + 78, + 247, + 23, + 79, + 152 + ] + }, + { + "key": [ + 183, + 255, + 132, + 2, + 241, + 50, + 93, + 148, + 92, + 152, + 102, + 32, + 3, + 50, + 61, + 183 + ], + "nonce": [ + 107, + 97, + 99, + 251, + 45, + 22, + 65, + 188, + 227, + 52, + 89, + 230 + ], + "aad": [ + 80, + 167, + 100, + 159, + 90, + 194, + 95, + 17, + 15, + 148, + 8, + 236, + 243, + 40, + 157, + 151, + 138, + 85, + 98, + 10 + ], + "plaintext": [ + 162, + 166, + 83, + 238, + 152, + 223, + 65, + 254, + 135, + 59, + 192, + 54, + 165, + 250, + 125, + 223, + 234, + 141, + 99, + 255, + 9, + 73, + 174, + 142, + 20, + 137, + 205, + 176, + 195, + 168, + 12, + 127 + ], + "ciphertext": [ + 130, + 10, + 55, + 63, + 68, + 106, + 131, + 65, + 200, + 217, + 40, + 210, + 35, + 165, + 174, + 168, + 84, + 182, + 67, + 255, + 7, + 144, + 43, + 12, + 91, + 208, + 198, + 49, + 155, + 66, + 216, + 85 + ], + "tag": [ + 118, + 76, + 105, + 222, + 237, + 83, + 58, + 178, + 155, + 216, + 93, + 211, + 93, + 77, + 207, + 154 + ] + }, + { + "key": [ + 72, + 201, + 1, + 186, + 78, + 144, + 91, + 214, + 138, + 253, + 174, + 199, + 57, + 174, + 0, + 194 + ], + "nonce": [ + 91, + 190, + 61, + 237, + 229, + 235, + 189, + 140, + 184, + 69, + 169, + 182 + ], + "aad": [ + 12, + 12, + 188, + 220, + 219, + 179, + 90, + 53, + 17, + 107, + 18, + 182, + 39, + 21, + 223, + 75, + 100, + 125, + 120, + 197 + ], + "plaintext": [ + 128, + 184, + 69, + 136, + 139, + 210, + 242, + 93, + 239, + 205, + 98, + 183, + 43, + 107, + 222, + 235, + 214, + 21, + 43, + 58, + 166, + 176, + 6, + 137, + 27, + 13, + 105, + 118, + 159, + 204, + 6, + 211 + ], + "ciphertext": [ + 81, + 39, + 121, + 88, + 45, + 31, + 225, + 131, + 31, + 51, + 59, + 181, + 99, + 99, + 74, + 206, + 248, + 2, + 28, + 60, + 118, + 176, + 107, + 235, + 108, + 125, + 169, + 141, + 170, + 196, + 194, + 41 + ], + "tag": [ + 21, + 253, + 50, + 249, + 106, + 75, + 149, + 5, + 188, + 19, + 115, + 82, + 93, + 64, + 238, + 183 + ] + }, + { + "key": [ + 200, + 44, + 196, + 217, + 255, + 6, + 129, + 150, + 136, + 57, + 153, + 26, + 253, + 13, + 252, + 42 + ], + "nonce": [ + 38, + 169, + 89, + 49, + 148, + 111, + 210, + 17, + 140, + 205, + 1, + 203 + ], + "aad": [ + 139, + 190, + 128, + 212, + 244, + 205, + 108, + 97, + 180, + 254, + 61, + 36, + 233, + 136, + 83, + 172, + 212, + 221, + 131, + 252 + ], + "plaintext": [ + 117, + 22, + 196, + 167, + 129, + 190, + 2, + 202, + 252, + 54, + 223, + 74, + 7, + 210, + 201, + 255, + 185, + 120, + 253, + 236, + 245, + 33, + 114, + 64, + 9, + 125, + 92, + 38, + 255, + 30, + 119, + 189 + ], + "ciphertext": [ + 249, + 132, + 54, + 254, + 75, + 246, + 229, + 153, + 58, + 218, + 176, + 240, + 0, + 27, + 235, + 251, + 68, + 151, + 53, + 235, + 54, + 91, + 158, + 124, + 228, + 177, + 81, + 248, + 32, + 5, + 197, + 199 + ], + "tag": [ + 200, + 59, + 228, + 97, + 225, + 254, + 219, + 180, + 221, + 243, + 238, + 114, + 185, + 222, + 190, + 32 + ] + }, + { + "key": [ + 116, + 138, + 136, + 191, + 78, + 38, + 74, + 17, + 128, + 191, + 214, + 101, + 7, + 42, + 186, + 101 + ], + "nonce": [ + 176, + 167, + 104, + 182, + 45, + 227, + 203, + 188, + 27, + 207, + 233, + 63 + ], + "aad": [ + 244, + 177, + 2, + 216, + 133, + 73, + 95, + 184, + 147, + 24, + 154, + 162, + 22, + 216, + 171, + 101, + 59, + 185, + 123, + 153 + ], + "plaintext": [ + 30, + 29, + 246, + 26, + 159, + 16, + 199, + 180, + 5, + 125, + 104, + 76, + 206, + 247, + 78, + 9, + 242, + 168, + 127, + 126, + 74, + 237, + 57, + 58, + 69, + 20, + 97, + 213, + 116, + 200, + 221, + 188 + ], + "ciphertext": [ + 94, + 26, + 249, + 81, + 25, + 137, + 6, + 154, + 97, + 90, + 104, + 80, + 64, + 37, + 71, + 239, + 71, + 136, + 25, + 116, + 82, + 70, + 31, + 18, + 65, + 226, + 75, + 230, + 116, + 198, + 0, + 116 + ], + "tag": [ + 115, + 78, + 28, + 201, + 55, + 202, + 56, + 78, + 40, + 36, + 16, + 253, + 159, + 196, + 191, + 242 + ] + }, + { + "key": [ + 35, + 147, + 24, + 11, + 184, + 19, + 32, + 150, + 90, + 88, + 66, + 75, + 40, + 124, + 155, + 62 + ], + "nonce": [ + 72, + 0, + 83, + 198, + 154, + 197, + 75, + 147, + 245, + 232, + 19, + 56 + ], + "aad": [ + 246, + 162, + 163, + 172, + 142, + 70, + 47, + 176, + 27, + 190, + 220, + 201, + 176, + 248, + 104, + 106, + 212, + 71, + 121, + 41 + ], + "plaintext": [ + 212, + 111, + 203, + 249, + 80, + 191, + 207, + 202, + 57, + 6, + 118, + 159, + 146, + 40, + 33, + 71, + 61, + 48, + 5, + 213, + 161, + 216, + 18, + 120, + 98, + 45, + 77, + 60, + 217, + 114, + 26, + 51 + ], + "ciphertext": [ + 18, + 88, + 116, + 255, + 90, + 127, + 137, + 54, + 167, + 107, + 17, + 88, + 123, + 190, + 189, + 70, + 30, + 39, + 99, + 139, + 255, + 90, + 30, + 153, + 52, + 101, + 201, + 205, + 232, + 47, + 43, + 212 + ], + "tag": [ + 155, + 98, + 91, + 76, + 47, + 102, + 207, + 47, + 200, + 128, + 67, + 185, + 180, + 198, + 242, + 250 + ] + }, + { + "key": [ + 214, + 81, + 22, + 107, + 175, + 66, + 183, + 90, + 219, + 38, + 227, + 112, + 183, + 96, + 22, + 229 + ], + "nonce": [ + 74, + 247, + 14, + 59, + 225, + 53, + 117, + 1, + 203, + 177, + 107, + 202 + ], + "aad": [ + 44, + 16, + 114, + 213, + 223, + 83, + 6, + 226, + 13, + 50, + 58, + 152, + 151, + 171, + 172, + 18, + 11, + 251, + 77, + 4 + ], + "plaintext": [ + 33, + 215, + 109, + 4, + 72, + 141, + 76, + 51, + 167, + 232, + 130, + 39, + 151, + 247, + 133, + 180, + 53, + 64, + 189, + 55, + 66, + 6, + 150, + 108, + 158, + 247, + 131, + 44, + 81, + 204, + 0, + 159 + ], + "ciphertext": [ + 188, + 85, + 117, + 114, + 73, + 15, + 77, + 99, + 129, + 31, + 141, + 131, + 229, + 130, + 20, + 186, + 77, + 141, + 36, + 41, + 2, + 100, + 56, + 24, + 56, + 50, + 138, + 41, + 98, + 240, + 16, + 178 + ], + "tag": [ + 139, + 209, + 246, + 92, + 85, + 28, + 74, + 255, + 165, + 23, + 168, + 176, + 59, + 99, + 55, + 226 + ] + }, + { + "key": [ + 72, + 183, + 243, + 55, + 205, + 249, + 37, + 38, + 135, + 236, + 199, + 96, + 189, + 142, + 193, + 132 + ], + "nonce": [ + 62, + 137, + 78, + 187, + 22, + 206, + 130, + 165, + 60, + 62, + 5, + 178 + ], + "aad": [ + 125, + 146, + 76, + 253, + 55, + 179, + 208, + 70, + 169, + 110, + 181, + 225, + 50, + 4, + 36, + 5, + 200, + 115, + 30, + 6, + 80, + 151, + 135, + 187, + 235, + 65, + 242, + 88, + 39, + 87, + 70, + 73, + 94, + 136, + 77, + 105, + 135, + 31, + 119, + 99, + 76, + 88, + 75, + 176, + 7, + 49, + 34, + 52 + ], + "plaintext": [ + 187, + 43, + 172, + 103, + 164, + 112, + 148, + 48, + 195, + 156, + 46, + 185, + 172, + 250, + 188, + 13, + 69, + 108, + 128, + 211, + 10, + 161, + 115, + 78, + 87, + 153, + 125, + 84, + 138, + 143, + 6, + 3 + ], + "ciphertext": [ + 210, + 99, + 34, + 139, + 140, + 224, + 81, + 246, + 126, + 155, + 175, + 28, + 231, + 223, + 151, + 209, + 12, + 213, + 243, + 188, + 151, + 35, + 98, + 5, + 81, + 48, + 199, + 209, + 60, + 58, + 178, + 231 + ], + "tag": [ + 113, + 68, + 103, + 55, + 202, + 31, + 169, + 46, + 109, + 2, + 109, + 125, + 46, + 209, + 170, + 156 + ] + }, + { + "key": [ + 53, + 167, + 234, + 190, + 125, + 226, + 209, + 118, + 233, + 124, + 219, + 144, + 92, + 11, + 127, + 23 + ], + "nonce": [ + 47, + 160, + 207, + 239, + 137, + 253, + 152, + 73, + 223, + 85, + 156, + 152 + ], + "aad": [ + 49, + 78, + 4, + 35, + 172, + 66, + 159, + 67, + 237, + 144, + 215, + 49, + 252, + 181, + 189, + 199, + 132, + 149, + 149, + 238, + 22, + 85, + 58, + 27, + 127, + 145, + 65, + 43, + 249, + 138, + 196, + 203, + 5, + 44, + 169, + 28, + 98, + 163, + 59, + 57, + 40, + 238, + 40, + 135, + 235, + 194, + 115, + 183 + ], + "plaintext": [ + 8, + 242, + 63, + 198, + 253, + 228, + 95, + 224, + 68, + 204, + 44, + 57, + 115, + 144, + 187, + 54, + 37, + 36, + 187, + 22, + 207, + 171, + 124, + 84, + 141, + 232, + 159, + 175, + 58, + 217, + 137, + 71 + ], + "ciphertext": [ + 207, + 4, + 1, + 116, + 248, + 226, + 128, + 209, + 10, + 166, + 94, + 181, + 157, + 184, + 191, + 62, + 78, + 42, + 138, + 160, + 27, + 31, + 50, + 5, + 100, + 49, + 73, + 70, + 179, + 116, + 154, + 242 + ], + "tag": [ + 148, + 247, + 140, + 138, + 185, + 97, + 7, + 67, + 120, + 38, + 5, + 14, + 26, + 137, + 185, + 226 + ] + }, + { + "key": [ + 35, + 195, + 30, + 14, + 80, + 237, + 68, + 250, + 231, + 230, + 223, + 56, + 171, + 240, + 177, + 106 + ], + "nonce": [ + 119, + 144, + 52, + 174, + 227, + 227, + 177, + 148, + 46, + 243, + 231, + 19 + ], + "aad": [ + 106, + 120, + 119, + 0, + 31, + 176, + 24, + 81, + 156, + 127, + 102, + 13, + 119, + 202, + 231, + 189, + 137, + 42, + 240, + 117, + 174, + 45, + 104, + 148, + 0, + 113, + 249, + 21, + 107, + 218, + 112, + 16, + 235, + 37, + 213, + 120, + 133, + 145, + 53, + 68, + 212, + 146, + 42, + 33, + 52, + 124, + 128, + 142 + ], + "plaintext": [ + 104, + 29, + 73, + 141, + 126, + 133, + 104, + 76, + 89, + 150, + 206, + 39, + 39, + 15, + 232, + 6, + 80, + 137, + 229, + 134, + 23, + 204, + 109, + 234, + 228, + 156, + 206, + 178, + 125, + 193, + 233, + 103 + ], + "ciphertext": [ + 123, + 20, + 161, + 86, + 116, + 117, + 91, + 102, + 175, + 8, + 213, + 129, + 238, + 111, + 139, + 152, + 105, + 25, + 39, + 203, + 31, + 92, + 67, + 229, + 88, + 157, + 230, + 28, + 27, + 56, + 131, + 201 + ], + "tag": [ + 47, + 164, + 13, + 156, + 101, + 238, + 210, + 138, + 153, + 249, + 90, + 244, + 104, + 41, + 48, + 6 + ] + }, + { + "key": [ + 75, + 79, + 145, + 85, + 216, + 219, + 133, + 224, + 226, + 179, + 107, + 243, + 170, + 152, + 30, + 108 + ], + "nonce": [ + 124, + 141, + 147, + 55, + 120, + 225, + 65, + 78, + 115, + 56, + 217, + 52 + ], + "aad": [ + 67, + 182, + 197, + 69, + 38, + 49, + 142, + 250, + 168, + 240, + 164, + 151, + 156, + 207, + 160, + 242, + 153, + 245, + 217, + 136, + 148, + 51, + 177, + 153, + 113, + 246, + 10, + 102, + 62, + 53, + 157, + 31, + 44, + 26, + 243, + 147, + 146, + 140, + 155, + 65, + 101, + 192, + 125, + 117, + 54, + 201, + 16, + 222 + ], + "plaintext": [ + 248, + 162, + 108, + 122, + 154, + 97, + 74, + 23, + 21, + 31, + 205, + 84, + 64, + 104, + 145, + 173, + 243, + 78, + 49, + 160, + 213, + 80, + 70, + 225, + 180, + 19, + 25, + 91, + 68, + 17, + 59, + 183 + ], + "ciphertext": [ + 63, + 155, + 222, + 163, + 195, + 86, + 26, + 212, + 23, + 194, + 5, + 136, + 122, + 234, + 108, + 161, + 238, + 7, + 0, + 87, + 56, + 141, + 200, + 2, + 38, + 243, + 49, + 255, + 176, + 1, + 125, + 229 + ], + "tag": [ + 232, + 234, + 29, + 48, + 119, + 223, + 44, + 61, + 32, + 240, + 42, + 80, + 70, + 253, + 174, + 115 + ] + }, + { + "key": [ + 65, + 72, + 221, + 135, + 188, + 106, + 170, + 144, + 138, + 13, + 190, + 30, + 93, + 47, + 108, + 199 + ], + "nonce": [ + 208, + 31, + 250, + 119, + 135, + 17, + 127, + 140, + 176, + 180, + 1, + 75 + ], + "aad": [ + 253, + 236, + 235, + 56, + 94, + 214, + 222, + 13, + 45, + 21, + 69, + 63, + 2, + 45, + 212, + 85, + 184, + 219, + 59, + 217, + 241, + 62, + 68, + 240, + 133, + 114, + 42, + 105, + 53, + 234, + 102, + 49, + 5, + 142, + 12, + 181, + 252, + 189, + 59, + 158, + 151, + 219, + 51, + 155, + 82, + 157, + 225, + 35 + ], + "plaintext": [ + 191, + 25, + 104, + 169, + 29, + 93, + 165, + 201, + 228, + 47, + 251, + 92, + 223, + 17, + 224, + 211, + 27, + 105, + 147, + 91, + 34, + 149, + 140, + 20, + 156, + 0, + 93, + 82, + 87, + 107, + 38, + 43 + ], + "ciphertext": [ + 191, + 201, + 236, + 187, + 175, + 73, + 55, + 17, + 7, + 206, + 195, + 127, + 128, + 23, + 31, + 148, + 20, + 30, + 37, + 164, + 134, + 225, + 180, + 45, + 130, + 88, + 32, + 138, + 96, + 56, + 250, + 52 + ], + "tag": [ + 242, + 218, + 208, + 177, + 107, + 183, + 40, + 203, + 149, + 122, + 217, + 171, + 7, + 22, + 209, + 149 + ] + }, + { + "key": [ + 93, + 80, + 150, + 26, + 167, + 250, + 215, + 202, + 233, + 168, + 208, + 67, + 225, + 145, + 201, + 198 + ], + "nonce": [ + 38, + 63, + 77, + 198, + 70, + 78, + 137, + 17, + 10, + 119, + 242, + 79 + ], + "aad": [ + 231, + 76, + 216, + 98, + 28, + 45, + 176, + 61, + 107, + 71, + 205, + 164, + 174, + 6, + 113, + 223, + 232, + 187, + 98, + 242, + 103, + 21, + 189, + 67, + 151, + 173, + 198, + 121, + 201, + 135, + 1, + 107, + 243, + 5, + 161, + 229, + 85, + 235, + 201, + 26, + 4, + 142, + 42, + 123, + 220, + 124, + 184, + 185 + ], + "plaintext": [ + 15, + 237, + 137, + 250, + 134, + 229, + 251, + 196, + 191, + 46, + 53, + 44, + 175, + 142, + 30, + 137, + 16, + 241, + 6, + 219, + 123, + 80, + 146, + 254, + 236, + 159, + 255, + 95, + 79, + 118, + 138, + 228 + ], + "ciphertext": [ + 33, + 144, + 56, + 11, + 238, + 16, + 173, + 233, + 115, + 174, + 160, + 219, + 38, + 152, + 53, + 100, + 159, + 78, + 83, + 228, + 114, + 69, + 152, + 225, + 169, + 53, + 112, + 74, + 64, + 65, + 27, + 22 + ], + "tag": [ + 10, + 163, + 214, + 141, + 144, + 239, + 61, + 50, + 159, + 243, + 148, + 69, + 29, + 176, + 162, + 194 + ] + }, + { + "key": [ + 194, + 66, + 139, + 84, + 167, + 129, + 36, + 47, + 137, + 107, + 188, + 136, + 22, + 232, + 23, + 107 + ], + "nonce": [ + 113, + 93, + 140, + 131, + 151, + 238, + 85, + 235, + 83, + 248, + 106, + 42 + ], + "aad": [ + 67, + 91, + 178, + 169, + 111, + 174, + 10, + 182, + 76, + 10, + 73, + 157, + 110, + 80, + 191, + 46, + 85, + 96, + 100, + 51, + 56, + 170, + 218, + 186, + 167, + 149, + 248, + 45, + 101, + 3, + 88, + 141, + 101, + 34, + 167, + 14, + 78, + 71, + 82, + 151, + 170, + 156, + 91, + 188, + 167, + 19, + 139, + 5 + ], + "plaintext": [ + 0, + 136, + 18, + 155, + 181, + 20, + 166, + 109, + 90, + 32, + 136, + 56, + 226, + 12, + 121, + 120, + 234, + 99, + 137, + 203, + 213, + 110, + 133, + 222, + 135, + 224, + 219, + 6, + 8, + 216, + 193, + 164 + ], + "ciphertext": [ + 169, + 251, + 117, + 12, + 0, + 159, + 253, + 127, + 231, + 103, + 3, + 227, + 88, + 143, + 116, + 127, + 165, + 140, + 239, + 104, + 177, + 217, + 221, + 47, + 149, + 59, + 191, + 58, + 182, + 218, + 43, + 89 + ], + "tag": [ + 97, + 59, + 185, + 18, + 57, + 170, + 253, + 206, + 216, + 251, + 135, + 182, + 186, + 15, + 158, + 93 + ] + }, + { + "key": [ + 106, + 52, + 8, + 72, + 26, + 84, + 161, + 217, + 35, + 17, + 66, + 255, + 185, + 253, + 53, + 79 + ], + "nonce": [ + 187, + 47, + 222, + 221, + 26, + 51, + 50, + 26, + 206, + 10, + 92, + 102 + ], + "aad": [ + 68, + 143, + 23, + 198, + 4, + 203, + 151, + 108, + 181, + 39, + 179, + 177, + 248, + 212, + 3, + 80, + 66, + 12, + 148, + 84, + 93, + 115, + 171, + 114, + 163, + 220, + 16, + 163, + 44, + 236, + 83, + 125, + 120, + 161, + 125, + 50, + 254, + 7, + 59, + 50, + 158, + 37, + 187, + 45, + 83, + 139, + 91, + 193 + ], + "plaintext": [ + 99, + 201, + 52, + 238, + 234, + 13, + 202, + 151, + 50, + 115, + 77, + 128, + 0, + 52, + 229, + 118, + 22, + 244, + 211, + 57, + 174, + 222, + 253, + 81, + 90, + 130, + 147, + 0, + 147, + 126, + 109, + 95 + ], + "ciphertext": [ + 180, + 19, + 169, + 200, + 66, + 250, + 81, + 0, + 27, + 137, + 73, + 170, + 129, + 223, + 193, + 4, + 8, + 57, + 24, + 146, + 237, + 168, + 71, + 133, + 231, + 37, + 116, + 83, + 120, + 83, + 109, + 36 + ], + "tag": [ + 30, + 50, + 61, + 18, + 133, + 106, + 100, + 74, + 134, + 243, + 148, + 249, + 97, + 133, + 160, + 122 + ] + }, + { + "key": [ + 197, + 167, + 239, + 151, + 10, + 127, + 66, + 184, + 49, + 148, + 191, + 170, + 98, + 220, + 9, + 44 + ], + "nonce": [ + 149, + 5, + 146, + 77, + 11, + 17, + 32, + 13, + 179, + 196, + 5, + 41 + ], + "aad": [ + 194, + 185, + 137, + 211, + 213, + 109, + 109, + 192, + 195, + 232, + 70, + 99, + 30, + 17, + 240, + 150, + 161, + 195, + 240, + 22, + 152, + 74, + 42, + 96, + 245, + 147, + 245, + 180, + 90, + 205, + 40, + 49, + 154, + 201, + 130, + 135, + 115, + 198, + 209, + 224, + 67, + 198, + 33, + 60, + 233, + 112, + 231, + 73 + ], + "plaintext": [ + 132, + 186, + 24, + 209, + 225, + 80, + 61, + 28, + 81, + 46, + 9, + 86, + 56, + 8, + 17, + 188, + 112, + 242, + 217, + 127, + 101, + 38, + 151, + 18, + 67, + 26, + 55, + 32, + 221, + 172, + 145, + 179 + ], + "ciphertext": [ + 176, + 124, + 2, + 218, + 191, + 250, + 168, + 247, + 177, + 31, + 100, + 78, + 84, + 127, + 136, + 127, + 120, + 189, + 201, + 186, + 187, + 170, + 12, + 166, + 110, + 53, + 14, + 43, + 90, + 41, + 59, + 53 + ], + "tag": [ + 17, + 57, + 61, + 244, + 50, + 99, + 109, + 199, + 215, + 163, + 241, + 131, + 245, + 49, + 22, + 106 + ] + }, + { + "key": [ + 63, + 69, + 197, + 199, + 208, + 66, + 238, + 52, + 232, + 37, + 123, + 248, + 58, + 70, + 20, + 78 + ], + "nonce": [ + 12, + 115, + 47, + 32, + 142, + 193, + 248, + 224, + 224, + 222, + 14, + 176 + ], + "aad": [ + 153, + 28, + 130, + 201, + 228, + 141, + 200, + 135, + 240, + 84, + 188, + 11, + 69, + 151, + 157, + 216, + 210, + 68, + 149, + 78, + 169, + 16, + 227, + 1, + 57, + 218, + 157, + 173, + 71, + 104, + 67, + 105, + 31, + 50, + 199, + 180, + 148, + 17, + 78, + 5, + 141, + 43, + 39, + 40, + 78, + 161, + 58, + 98 + ], + "plaintext": [ + 212, + 111, + 175, + 223, + 4, + 70, + 142, + 145, + 185, + 184, + 122, + 132, + 247, + 18, + 97, + 188, + 212, + 75, + 67, + 142, + 58, + 148, + 53, + 144, + 198, + 209, + 153, + 7, + 134, + 144, + 158, + 193 + ], + "ciphertext": [ + 84, + 203, + 177, + 131, + 40, + 104, + 32, + 55, + 189, + 221, + 184, + 197, + 133, + 183, + 49, + 177, + 139, + 92, + 252, + 73, + 93, + 155, + 137, + 156, + 155, + 141, + 184, + 161, + 29, + 158, + 70, + 233 + ], + "tag": [ + 40, + 147, + 73, + 234, + 9, + 72, + 57, + 220, + 110, + 149, + 112, + 193, + 215, + 214, + 42, + 145 + ] + }, + { + "key": [ + 16, + 240, + 86, + 155, + 78, + 108, + 68, + 24, + 88, + 248, + 5, + 58, + 100, + 107, + 119, + 95 + ], + "nonce": [ + 134, + 61, + 189, + 201, + 235, + 138, + 156, + 26, + 193, + 175, + 106, + 201 + ], + "aad": [ + 65, + 211, + 114, + 222, + 186, + 155, + 37, + 187, + 152, + 45, + 140, + 70, + 98, + 240, + 99, + 249, + 93, + 24, + 89, + 100, + 5, + 80, + 238, + 97, + 119, + 134, + 38, + 68, + 176, + 40, + 244, + 44, + 67, + 86, + 54, + 205, + 192, + 205, + 197, + 117, + 9, + 165, + 252, + 183, + 86, + 87, + 229, + 129 + ], + "plaintext": [ + 249, + 158, + 234, + 213, + 27, + 178, + 161, + 127, + 55, + 10, + 80, + 7, + 157, + 147, + 22, + 113, + 121, + 175, + 92, + 73, + 150, + 90, + 242, + 211, + 240, + 109, + 33, + 31, + 217, + 109, + 107, + 160 + ], + "ciphertext": [ + 86, + 111, + 89, + 207, + 79, + 231, + 177, + 77, + 202, + 53, + 87, + 87, + 67, + 134, + 115, + 81, + 241, + 139, + 31, + 167, + 227, + 148, + 23, + 248, + 231, + 254, + 78, + 139, + 241, + 5, + 44, + 164 + ], + "tag": [ + 223, + 57, + 194, + 145, + 178, + 111, + 140, + 162, + 85, + 122, + 188, + 96, + 116, + 105, + 64, + 112 + ] + }, + { + "key": [ + 102, + 249, + 88, + 224, + 152, + 150, + 171, + 43, + 33, + 235, + 54, + 252, + 54, + 251, + 252, + 173 + ], + "nonce": [ + 55, + 26, + 77, + 189, + 248, + 14, + 109, + 70, + 80, + 138, + 150, + 33 + ], + "aad": [ + 25, + 241, + 158, + 175, + 182, + 25, + 31, + 176, + 69, + 40, + 7, + 186, + 43, + 166, + 174, + 74, + 195, + 107, + 55, + 19, + 143, + 9, + 44, + 186, + 26, + 99, + 190, + 88, + 228, + 248, + 185, + 148, + 242, + 246, + 149, + 135, + 153, + 68, + 107, + 93, + 34, + 111, + 210, + 58, + 149, + 254, + 121, + 59 + ], + "plaintext": [ + 192, + 69, + 143, + 89, + 186, + 192, + 57, + 164, + 52, + 158, + 57, + 194, + 89, + 237, + 246, + 207, + 98, + 251, + 216, + 121, + 16, + 6, + 68, + 9, + 198, + 77, + 143, + 110, + 245, + 93, + 150, + 239 + ], + "ciphertext": [ + 25, + 36, + 116, + 173, + 121, + 94, + 62, + 62, + 54, + 171, + 206, + 242, + 212, + 44, + 3, + 141, + 57, + 236, + 232, + 17, + 159, + 176, + 88, + 167, + 82, + 183, + 149, + 159, + 228, + 103, + 3, + 245 + ], + "tag": [ + 209, + 125, + 198, + 29, + 21, + 19, + 252, + 28, + 194, + 223, + 69, + 40, + 58, + 254, + 181, + 86 + ] + }, + { + "key": [ + 15, + 70, + 239, + 105, + 153, + 163, + 203, + 204, + 46, + 83, + 154, + 137, + 82, + 167, + 251, + 204 + ], + "nonce": [ + 255, + 136, + 41, + 194, + 251, + 86, + 205, + 247, + 73, + 20, + 173, + 45 + ], + "aad": [ + 252, + 154, + 28, + 22, + 176, + 244, + 207, + 19, + 56, + 67, + 167, + 102, + 74, + 23, + 233, + 124, + 2, + 231, + 170, + 54, + 1, + 83, + 245, + 180, + 184, + 129, + 237, + 56, + 37, + 247, + 178, + 164, + 20, + 173, + 174, + 148, + 201, + 166, + 71, + 154, + 158, + 234, + 170, + 32, + 111, + 153, + 195, + 219 + ], + "plaintext": [ + 55, + 64, + 29, + 86, + 5, + 36, + 18, + 249, + 26, + 169, + 57, + 143, + 58, + 179, + 175, + 230, + 138, + 229, + 0, + 170, + 244, + 15, + 121, + 65, + 200, + 168, + 42, + 229, + 99, + 121, + 253, + 93 + ], + "ciphertext": [ + 104, + 102, + 170, + 118, + 153, + 168, + 206, + 44, + 116, + 120, + 128, + 0, + 25, + 135, + 194, + 131, + 147, + 254, + 168, + 10, + 203, + 123, + 36, + 169, + 230, + 230, + 16, + 134, + 223, + 104, + 245, + 182 + ], + "tag": [ + 201, + 150, + 252, + 62, + 68, + 136, + 122, + 212, + 215, + 3, + 183, + 45, + 194, + 236, + 177, + 184 + ] + }, + { + "key": [ + 144, + 131, + 130, + 9, + 187, + 200, + 208, + 120, + 70, + 18, + 118, + 103, + 86, + 77, + 214, + 150 + ], + "nonce": [ + 254, + 191, + 180, + 221, + 4, + 235, + 49, + 57, + 51, + 185, + 194, + 120 + ], + "aad": [ + 1, + 203, + 179, + 167, + 167, + 0, + 1, + 2, + 123, + 6, + 76, + 51, + 114, + 96, + 221, + 222, + 140, + 208, + 127, + 199, + 134, + 215, + 30, + 41, + 63, + 224, + 189, + 68, + 199, + 148, + 219, + 247, + 176, + 84, + 17, + 75, + 205, + 37, + 158, + 17, + 94, + 58, + 204, + 152, + 205, + 46, + 215, + 177 + ], + "plaintext": [ + 206, + 192, + 82, + 115, + 41, + 132, + 122, + 126, + 236, + 230, + 175, + 166, + 92, + 127, + 80, + 255, + 45, + 125, + 244, + 188, + 78, + 141, + 41, + 144, + 196, + 27, + 244, + 42, + 169, + 189, + 166, + 21 + ], + "ciphertext": [ + 230, + 39, + 84, + 112, + 69, + 74, + 158, + 11, + 111, + 110, + 162, + 164, + 214, + 76, + 185, + 52, + 98, + 166, + 205, + 220, + 105, + 232, + 15, + 51, + 128, + 152, + 254, + 139, + 29, + 75, + 195, + 100 + ], + "tag": [ + 80, + 221, + 194, + 84, + 215, + 80, + 69, + 144, + 201, + 56, + 165, + 3, + 4, + 140, + 200, + 254 + ] + }, + { + "key": [ + 249, + 78, + 157, + 128, + 180, + 141, + 197, + 189, + 202, + 130, + 241, + 77, + 170, + 70, + 190, + 22 + ], + "nonce": [ + 41, + 191, + 25, + 49, + 240, + 220, + 79, + 227, + 200, + 7, + 226, + 52 + ], + "aad": [ + 68, + 158, + 104, + 215, + 143, + 202, + 162, + 224, + 242, + 129, + 26, + 135, + 169, + 196, + 138, + 60, + 209, + 142, + 77, + 100, + 78, + 184, + 142, + 240, + 91, + 145, + 244, + 82, + 142, + 53, + 199, + 19, + 244, + 223, + 47, + 249, + 125, + 226, + 81, + 188, + 91, + 4, + 161, + 119, + 210, + 226, + 146, + 153 + ], + "plaintext": [ + 100, + 151, + 31, + 223, + 116, + 249, + 63, + 138, + 174, + 50, + 169, + 152, + 229, + 172, + 242, + 176, + 150, + 35, + 121, + 90, + 119, + 203, + 154, + 216, + 136, + 171, + 230, + 199, + 117, + 107, + 10, + 157 + ], + "ciphertext": [ + 243, + 23, + 96, + 125, + 151, + 237, + 81, + 252, + 194, + 246, + 255, + 123, + 57, + 68, + 112, + 117, + 141, + 247, + 114, + 171, + 179, + 59, + 123, + 160, + 73, + 198, + 116, + 139, + 57, + 252, + 64, + 5 + ], + "tag": [ + 108, + 71, + 59, + 188, + 136, + 129, + 35, + 159, + 133, + 237, + 220, + 121, + 245, + 218, + 160, + 185 + ] + }, + { + "key": [ + 143, + 191, + 124, + 161, + 47, + 213, + 37, + 221, + 233, + 30, + 98, + 88, + 115, + 254, + 81, + 194 + ], + "nonce": [ + 32, + 11, + 234, + 81, + 123, + 151, + 144, + 161, + 207, + 173, + 175, + 94 + ], + "aad": [ + 164, + 20, + 192, + 127, + 226, + 230, + 11, + 236, + 156, + 204, + 64, + 158, + 158, + 137, + 156, + 111, + 230, + 5, + 128, + 187, + 38, + 7, + 200, + 97, + 247, + 240, + 133, + 35, + 230, + 156, + 218, + 27, + 156, + 58, + 113, + 29, + 29, + 156, + 53, + 9, + 23, + 113, + 228, + 201, + 80, + 185, + 153, + 109, + 10, + 208, + 79, + 46, + 0, + 209, + 179, + 16, + 88, + 83, + 84, + 42, + 150, + 224, + 159, + 255, + 252, + 46, + 200, + 15, + 140, + 248, + 135, + 40, + 245, + 148, + 240, + 174, + 177, + 79, + 152, + 166, + 136, + 35, + 78, + 139, + 251, + 247, + 3, + 39, + 179, + 100 + ], + "plaintext": [ + 57, + 211, + 230, + 39, + 124, + 75, + 73, + 99, + 132, + 13, + 22, + 66, + 230, + 250, + 174, + 10, + 91, + 226, + 218, + 151, + 246, + 28, + 78, + 85, + 187, + 87, + 206, + 2, + 25, + 3, + 212, + 196 + ], + "ciphertext": [ + 254, + 103, + 142, + 247, + 111, + 105, + 172, + 149, + 219, + 85, + 59, + 109, + 173, + 213, + 160, + 122, + 157, + 200, + 225, + 81, + 254, + 106, + 159, + 163, + 161, + 205, + 98, + 22, + 54, + 184, + 120, + 104 + ], + "tag": [ + 124, + 134, + 7, + 116, + 248, + 131, + 50, + 185, + 167, + 206, + 107, + 189, + 2, + 114, + 167, + 39 + ] + }, + { + "key": [ + 147, + 164, + 91, + 22, + 242, + 192, + 106, + 72, + 114, + 24, + 215, + 97, + 234, + 191, + 24, + 115 + ], + "nonce": [ + 246, + 88, + 237, + 124, + 229, + 8, + 231, + 16, + 213, + 129, + 95, + 24 + ], + "aad": [ + 51, + 21, + 106, + 119, + 85, + 134, + 232, + 201, + 44, + 126, + 153, + 196, + 103, + 168, + 64, + 40, + 26, + 188, + 25, + 72, + 59, + 154, + 50, + 14, + 112, + 123, + 241, + 255, + 232, + 86, + 255, + 28, + 71, + 59, + 181, + 47, + 91, + 148, + 14, + 68, + 223, + 44, + 47, + 118, + 108, + 190, + 158, + 211, + 96, + 216, + 68, + 40, + 63, + 141, + 170, + 62, + 246, + 141, + 239, + 75, + 245, + 242, + 195, + 170, + 227, + 2, + 140, + 45, + 52, + 140, + 161, + 150, + 62, + 146, + 39, + 205, + 250, + 111, + 98, + 5, + 219, + 217, + 243, + 131, + 46, + 70, + 164, + 245, + 82, + 236 + ], + "plaintext": [ + 182, + 162, + 175, + 185, + 22, + 162, + 53, + 199, + 250, + 197, + 205, + 106, + 142, + 144, + 87, + 194, + 255, + 244, + 55, + 183, + 84, + 69, + 50, + 162, + 150, + 163, + 200, + 12, + 53, + 244, + 124, + 153 + ], + "ciphertext": [ + 101, + 100, + 225, + 82, + 135, + 233, + 149, + 136, + 99, + 149, + 53, + 60, + 101, + 200, + 48, + 230, + 253, + 210, + 149, + 199, + 236, + 38, + 51, + 199, + 248, + 210, + 128, + 242, + 52, + 12, + 221, + 21 + ], + "tag": [ + 228, + 244, + 223, + 239, + 118, + 66, + 112, + 160, + 104, + 169, + 9, + 91, + 150, + 24, + 255, + 239 + ] + }, + { + "key": [ + 80, + 21, + 246, + 178, + 103, + 247, + 186, + 143, + 131, + 180, + 110, + 249, + 68, + 10, + 0, + 131 + ], + "nonce": [ + 182, + 109, + 212, + 46, + 105, + 248, + 166, + 20, + 81, + 106, + 182, + 207 + ], + "aad": [ + 240, + 111, + 225, + 135, + 173, + 85, + 223, + 76, + 21, + 117, + 4, + 58, + 251, + 73, + 12, + 17, + 124, + 102, + 230, + 49, + 182, + 160, + 38, + 172, + 139, + 54, + 99, + 214, + 95, + 78, + 96, + 91, + 87, + 244, + 103, + 237, + 108, + 10, + 63, + 222, + 3, + 219, + 97, + 248, + 45, + 152, + 162, + 56, + 149, + 90, + 62, + 15, + 81, + 186, + 199, + 141, + 20, + 185, + 74, + 11, + 117, + 5, + 122, + 67, + 47, + 243, + 117, + 160, + 155, + 10, + 65, + 222, + 243, + 200, + 135, + 252, + 177, + 3, + 238, + 153, + 244, + 185, + 244, + 71, + 74, + 100, + 96, + 11, + 135, + 235 + ], + "plaintext": [ + 209, + 32, + 117, + 73, + 204, + 131, + 26, + 74, + 252, + 126, + 130, + 65, + 87, + 118, + 165, + 164, + 38, + 100, + 188, + 51, + 131, + 61, + 6, + 29, + 164, + 9, + 251, + 225, + 251, + 30, + 132, + 223 + ], + "ciphertext": [ + 150, + 0, + 183, + 170, + 111, + 93, + 142, + 48, + 211, + 187, + 202, + 104, + 0, + 100, + 62, + 231, + 100, + 181, + 155, + 203, + 131, + 222, + 61, + 253, + 3, + 54, + 75, + 188, + 154, + 72, + 37, + 46 + ], + "tag": [ + 73, + 160, + 173, + 45, + 251, + 180, + 158, + 138, + 204, + 106, + 209, + 222, + 77, + 147, + 17, + 215 + ] + }, + { + "key": [ + 64, + 135, + 34, + 232, + 13, + 156, + 174, + 33, + 49, + 128, + 239, + 192, + 242, + 103, + 95, + 50 + ], + "nonce": [ + 233, + 237, + 21, + 177, + 148, + 47, + 26, + 181, + 233, + 207, + 148, + 33 + ], + "aad": [ + 25, + 251, + 112, + 52, + 172, + 79, + 87, + 3, + 92, + 241, + 159, + 104, + 215, + 108, + 69, + 129, + 5, + 78, + 219, + 171, + 232, + 132, + 224, + 118, + 160, + 73, + 133, + 66, + 212, + 47, + 4, + 18, + 245, + 235, + 135, + 194, + 202, + 251, + 225, + 59, + 153, + 54, + 198, + 252, + 238, + 76, + 123, + 180, + 109, + 242, + 39, + 67, + 6, + 251, + 26, + 134, + 186, + 228, + 102, + 2, + 144, + 193, + 62, + 221, + 235, + 140, + 254, + 141, + 229, + 133, + 228, + 21, + 86, + 59, + 193, + 166, + 202, + 152, + 35, + 182, + 108, + 143, + 45, + 165, + 218, + 93, + 248, + 244, + 22, + 119 + ], + "plaintext": [ + 57, + 237, + 69, + 189, + 215, + 63, + 114, + 170, + 22, + 174, + 131, + 61, + 5, + 198, + 217, + 171, + 31, + 202, + 43, + 94, + 164, + 120, + 219, + 85, + 48, + 39, + 120, + 120, + 87, + 252, + 159, + 205 + ], + "ciphertext": [ + 146, + 65, + 82, + 108, + 99, + 140, + 47, + 10, + 45, + 30, + 82, + 187, + 4, + 159, + 113, + 3, + 149, + 101, + 187, + 165, + 197, + 152, + 118, + 235, + 19, + 111, + 146, + 172, + 104, + 172, + 127, + 108 + ], + "tag": [ + 166, + 169, + 182, + 44, + 54, + 177, + 86, + 173, + 64, + 36, + 231, + 5, + 193, + 215, + 131, + 96 + ] + }, + { + "key": [ + 103, + 140, + 75, + 244, + 20, + 69, + 47, + 28, + 90, + 101, + 150, + 105, + 100, + 109, + 65, + 97 + ], + "nonce": [ + 41, + 93, + 39, + 98, + 38, + 29, + 26, + 83, + 110, + 28, + 5, + 124 + ], + "aad": [ + 188, + 132, + 116, + 58, + 12, + 66, + 187, + 52, + 35, + 3, + 42, + 137, + 133, + 125, + 229, + 169, + 53, + 94, + 215, + 130, + 25, + 128, + 191, + 24, + 55, + 154, + 229, + 3, + 182, + 157, + 163, + 86, + 1, + 96, + 143, + 98, + 187, + 252, + 178, + 226, + 173, + 158, + 255, + 126, + 3, + 252, + 180, + 182, + 209, + 118, + 138, + 211, + 164, + 217, + 40, + 49, + 197, + 178, + 227, + 252, + 14, + 234, + 58, + 183, + 184, + 116, + 246, + 78, + 132, + 195, + 118, + 168, + 249, + 225, + 91, + 154, + 235, + 83, + 146, + 222, + 16, + 18, + 38, + 5, + 105, + 159, + 125, + 3, + 169, + 153 + ], + "plaintext": [ + 83, + 244, + 171, + 120, + 193, + 106, + 32, + 192, + 112, + 149, + 175, + 165, + 15, + 126, + 150, + 214, + 107, + 219, + 93, + 169, + 14, + 126, + 58, + 138, + 73, + 250, + 195, + 70, + 82, + 114, + 110, + 221 + ], + "ciphertext": [ + 44, + 130, + 26, + 14, + 182, + 28, + 189, + 176, + 159, + 132, + 240, + 134, + 246, + 150, + 82, + 179, + 138, + 201, + 208, + 122, + 144, + 152, + 95, + 62, + 243, + 100, + 130, + 169, + 239, + 142, + 219, + 178 + ], + "tag": [ + 230, + 224, + 66, + 254, + 8, + 148, + 223, + 69, + 183, + 217, + 137, + 142, + 150, + 233, + 185, + 6 + ] + }, + { + "key": [ + 141, + 248, + 67, + 173, + 147, + 118, + 215, + 50, + 97, + 20, + 20, + 56, + 153, + 180, + 202, + 111 + ], + "nonce": [ + 205, + 243, + 184, + 134, + 19, + 228, + 133, + 254, + 104, + 134, + 231, + 32 + ], + "aad": [ + 229, + 189, + 127, + 168, + 165, + 111, + 60, + 21, + 81, + 32, + 243, + 188, + 203, + 15, + 165, + 87, + 6, + 62, + 123, + 185, + 81, + 124, + 208, + 77, + 153, + 150, + 83, + 62, + 243, + 146, + 78, + 230, + 25, + 126, + 231, + 81, + 44, + 110, + 240, + 157, + 33, + 119, + 231, + 91, + 73, + 9, + 198, + 207, + 240, + 232, + 108, + 218, + 220, + 226, + 14, + 39, + 154, + 5, + 3, + 149, + 111, + 76, + 33, + 150, + 57, + 26, + 143, + 254, + 194, + 209, + 122, + 29, + 102, + 20, + 190, + 120, + 71, + 205, + 17, + 77, + 247, + 11, + 147, + 149, + 159, + 23, + 101, + 130, + 101, + 146 + ], + "plaintext": [ + 193, + 252, + 253, + 163, + 39, + 83, + 61, + 23, + 225, + 166, + 172, + 126, + 37, + 204, + 160, + 37, + 70, + 198, + 102, + 53, + 161, + 21, + 207, + 63, + 109, + 0, + 142, + 186, + 85, + 148, + 125, + 96 + ], + "ciphertext": [ + 113, + 184, + 34, + 182, + 211, + 156, + 154, + 128, + 26, + 76, + 42, + 44, + 145, + 115, + 176, + 243, + 217, + 181, + 12, + 241, + 142, + 142, + 149, + 41, + 17, + 54, + 82, + 122, + 151, + 120, + 237, + 194 + ], + "tag": [ + 181, + 132, + 167, + 229, + 29, + 64, + 171, + 40, + 115, + 44, + 17, + 237, + 96, + 39, + 48, + 165 + ] + }, + { + "key": [ + 100, + 180, + 61, + 252, + 220, + 243, + 13, + 251, + 151, + 55, + 61, + 117, + 208, + 154, + 183, + 51 + ], + "nonce": [ + 147, + 89, + 216, + 83, + 97, + 163, + 228, + 193, + 16, + 215, + 21, + 244 + ], + "aad": [ + 1, + 172, + 238, + 98, + 150, + 71, + 129, + 52, + 153, + 146, + 128, + 237, + 71, + 165, + 188, + 101, + 221, + 81, + 34, + 197, + 211, + 80, + 146, + 223, + 84, + 113, + 137, + 0, + 208, + 76, + 251, + 129, + 69, + 123, + 169, + 236, + 157, + 1, + 229, + 93, + 216, + 166, + 93, + 107, + 56, + 101, + 250, + 14, + 122, + 69, + 56, + 47, + 40, + 124, + 104, + 140, + 81, + 255, + 204, + 149, + 25, + 69, + 227, + 233, + 200, + 123, + 3, + 197, + 84, + 92, + 236, + 13, + 150, + 105, + 38, + 184, + 238, + 4, + 83, + 182, + 159, + 37, + 206, + 159, + 223, + 10, + 48, + 101, + 200, + 30 + ], + "plaintext": [ + 124, + 92, + 148, + 172, + 123, + 19, + 130, + 115, + 222, + 118, + 141, + 43, + 218, + 22, + 190, + 240, + 119, + 71, + 153, + 223, + 51, + 63, + 221, + 26, + 117, + 110, + 52, + 78, + 195, + 95, + 40, + 68 + ], + "ciphertext": [ + 95, + 154, + 166, + 21, + 225, + 59, + 123, + 88, + 91, + 220, + 45, + 76, + 58, + 131, + 209, + 48, + 77, + 111, + 120, + 235, + 186, + 13, + 91, + 50, + 157, + 134, + 202, + 115, + 10, + 81, + 87, + 2 + ], + "tag": [ + 60, + 191, + 159, + 165, + 48, + 176, + 73, + 224, + 103, + 134, + 132, + 51, + 48, + 116, + 37, + 219 + ] + }, + { + "key": [ + 147, + 169, + 81, + 41, + 93, + 68, + 40, + 144, + 42, + 92, + 206, + 143, + 226, + 6, + 135, + 99 + ], + "nonce": [ + 138, + 237, + 53, + 174, + 74, + 231, + 20, + 207, + 117, + 110, + 104, + 107 + ], + "aad": [ + 129, + 134, + 120, + 138, + 147, + 167, + 100, + 168, + 102, + 148, + 74, + 32, + 86, + 39, + 154, + 215, + 241, + 210, + 8, + 58, + 150, + 206, + 34, + 79, + 230, + 222, + 96, + 231, + 11, + 23, + 219, + 24, + 2, + 42, + 21, + 4, + 225, + 191, + 69, + 195, + 38, + 198, + 214, + 153, + 45, + 140, + 0, + 91, + 103, + 87, + 21, + 1, + 110, + 0, + 236, + 150, + 91, + 57, + 139, + 46, + 164, + 171, + 9, + 204, + 162, + 172, + 74, + 195, + 18, + 230, + 132, + 12, + 224, + 10, + 54, + 246, + 70, + 112, + 40, + 50, + 143, + 163, + 13, + 64, + 134, + 229, + 188, + 182, + 119, + 186 + ], + "plaintext": [ + 0, + 41, + 183, + 73, + 180, + 219, + 71, + 125, + 207, + 71, + 208, + 41, + 110, + 184, + 136, + 6, + 239, + 11, + 86, + 6, + 13, + 89, + 142, + 72, + 201, + 181, + 166, + 249, + 208, + 70, + 64, + 77 + ], + "ciphertext": [ + 121, + 44, + 209, + 161, + 67, + 48, + 79, + 199, + 55, + 208, + 115, + 155, + 229, + 43, + 46, + 97, + 132, + 26, + 144, + 137, + 99, + 131, + 44, + 255, + 6, + 171, + 110, + 197, + 133, + 190, + 100, + 103 + ], + "tag": [ + 225, + 187, + 62, + 172, + 127, + 87, + 0, + 85, + 252, + 45, + 47, + 5, + 136, + 196, + 147, + 94 + ] + }, + { + "key": [ + 79, + 49, + 20, + 113, + 12, + 14, + 127, + 57, + 59, + 145, + 201, + 130, + 190, + 179, + 207, + 204 + ], + "nonce": [ + 3, + 153, + 77, + 11, + 36, + 79, + 148, + 209, + 60, + 237, + 206, + 144 + ], + "aad": [ + 210, + 148, + 249, + 57, + 54, + 26, + 241, + 191, + 245, + 103, + 74, + 82, + 53, + 186, + 62, + 121, + 191, + 48, + 165, + 52, + 27, + 134, + 52, + 181, + 218, + 198, + 19, + 233, + 165, + 103, + 204, + 206, + 1, + 176, + 89, + 98, + 130, + 234, + 88, + 78, + 87, + 151, + 25, + 32, + 107, + 35, + 19, + 246, + 103, + 94, + 120, + 52, + 248, + 166, + 217, + 65, + 225, + 100, + 22, + 158, + 151, + 100, + 140, + 231, + 121, + 104, + 171, + 78, + 205, + 251, + 61, + 99, + 152, + 152, + 70, + 138, + 30, + 141, + 40, + 90, + 147, + 39, + 220, + 149, + 128, + 147, + 235, + 51, + 248, + 177 + ], + "plaintext": [ + 54, + 131, + 23, + 68, + 253, + 28, + 23, + 165, + 223, + 101, + 166, + 61, + 102, + 66, + 80, + 32, + 117, + 160, + 16, + 159, + 15, + 12, + 9, + 63, + 243, + 53, + 5, + 20, + 3, + 113, + 19, + 108 + ], + "ciphertext": [ + 85, + 126, + 120, + 53, + 14, + 190, + 83, + 209, + 183, + 193, + 101, + 38, + 105, + 98, + 29, + 183, + 167, + 26, + 143, + 226, + 192, + 168, + 78, + 97, + 186, + 223, + 45, + 217, + 240, + 52, + 185, + 27 + ], + "tag": [ + 188, + 108, + 31, + 19, + 34, + 6, + 78, + 171, + 117, + 115, + 112, + 103, + 151, + 61, + 86, + 167 + ] + }, + { + "key": [ + 240, + 10, + 3, + 78, + 162, + 247, + 50, + 134, + 63, + 144, + 48, + 37, + 124, + 141, + 203, + 249 + ], + "nonce": [ + 43, + 210, + 136, + 252, + 47, + 171, + 186, + 108, + 68, + 160, + 71, + 5 + ], + "aad": [ + 49, + 45, + 224, + 39, + 37, + 165, + 59, + 138, + 61, + 202, + 127, + 2, + 135, + 109, + 217, + 164, + 102, + 93, + 231, + 163, + 243, + 218, + 183, + 228, + 172, + 55, + 183, + 29, + 157, + 2, + 71, + 136, + 41, + 202, + 56, + 211, + 236, + 118, + 215, + 121, + 46, + 179, + 36, + 120, + 185, + 37, + 82, + 233, + 1, + 84, + 207, + 86, + 8, + 220, + 173, + 79, + 51, + 73, + 96, + 97, + 22, + 26, + 249, + 51, + 208, + 102, + 225, + 70, + 136, + 141, + 27, + 127, + 169, + 176, + 197, + 37, + 93, + 89, + 168, + 253, + 216, + 141, + 166, + 56, + 208, + 110, + 230, + 209, + 109, + 147 + ], + "plaintext": [ + 133, + 71, + 32, + 145, + 163, + 126, + 197, + 243, + 125, + 80, + 252, + 9, + 251, + 107, + 157, + 128, + 53, + 119, + 34, + 123, + 76, + 7, + 154, + 230, + 74, + 146, + 100, + 231, + 167, + 132, + 196, + 252 + ], + "ciphertext": [ + 154, + 162, + 120, + 16, + 195, + 118, + 26, + 225, + 117, + 86, + 3, + 64, + 20, + 70, + 16, + 199, + 210, + 99, + 173, + 53, + 35, + 78, + 204, + 85, + 254, + 237, + 28, + 93, + 211, + 164, + 218, + 223 + ], + "tag": [ + 2, + 114, + 77, + 20, + 167, + 220, + 181, + 239, + 129, + 206, + 138, + 169, + 55, + 241, + 65, + 157 + ] + }, + { + "key": [ + 73, + 223, + 189, + 54, + 138, + 84, + 23, + 33, + 214, + 205, + 91, + 37, + 19, + 236, + 96, + 135 + ], + "nonce": [ + 139, + 2, + 20, + 236, + 58, + 106, + 106, + 246, + 91, + 232, + 76, + 235 + ], + "aad": [ + 109, + 61, + 200, + 106, + 244, + 187, + 158, + 146, + 175, + 13, + 236, + 140, + 234, + 152, + 20, + 129, + 52, + 31, + 55, + 190, + 69, + 112, + 147, + 217, + 138, + 129, + 141, + 140, + 180, + 182, + 139, + 159, + 113, + 151, + 177, + 250, + 49, + 1, + 71, + 112, + 31, + 4, + 121, + 73, + 175, + 65, + 208, + 178, + 38, + 175, + 74, + 59, + 11, + 146, + 229, + 52, + 34, + 36, + 118, + 109, + 171, + 120, + 48, + 225, + 104, + 122, + 163, + 145, + 138, + 137, + 212, + 211, + 181, + 13, + 105, + 89, + 89, + 68, + 244, + 146, + 211, + 214, + 139, + 54, + 9, + 202, + 89, + 78, + 127, + 38 + ], + "plaintext": [ + 239, + 108, + 255, + 8, + 203, + 203, + 99, + 167, + 46, + 132, + 19, + 64, + 81, + 63, + 78, + 40, + 154, + 211, + 78, + 137, + 115, + 55, + 49, + 69, + 108, + 191, + 188, + 154, + 135, + 178, + 15, + 155 + ], + "ciphertext": [ + 224, + 128, + 46, + 96, + 247, + 58, + 162, + 253, + 102, + 156, + 245, + 135, + 14, + 150, + 59, + 31, + 51, + 112, + 122, + 212, + 204, + 85, + 31, + 101, + 139, + 24, + 187, + 114, + 253, + 124, + 217, + 227 + ], + "tag": [ + 205, + 109, + 154, + 51, + 69, + 138, + 199, + 9, + 56, + 90, + 207, + 188, + 255, + 164, + 87, + 229 + ] + }, + { + "key": [ + 60, + 15, + 87, + 152, + 36, + 73, + 250, + 211, + 57, + 199, + 172, + 95, + 101, + 1, + 185, + 236 + ], + "nonce": [ + 77, + 182, + 48, + 27, + 99, + 139, + 171, + 106, + 131, + 48, + 1, + 235 + ], + "aad": [ + 234, + 56, + 114, + 176, + 212, + 141, + 173, + 100, + 154, + 135, + 106, + 107, + 54, + 114, + 233, + 199, + 255, + 205, + 105, + 105, + 90, + 77, + 46, + 177, + 133, + 62, + 213, + 194, + 110, + 202, + 14, + 143, + 33, + 56, + 85, + 99, + 212, + 45, + 254, + 242, + 225, + 67, + 14, + 6, + 86, + 27, + 142, + 11, + 115, + 181, + 246, + 43, + 165, + 26, + 74, + 202, + 120, + 197, + 108, + 6, + 196, + 121, + 150, + 28, + 61, + 33, + 193, + 250, + 56, + 35, + 207, + 128, + 20, + 95, + 123, + 36, + 228, + 116, + 1, + 39, + 233, + 233, + 150, + 15, + 162, + 72, + 14, + 54, + 228, + 196 + ], + "plaintext": [ + 209, + 213, + 225, + 243, + 216, + 180, + 145, + 178, + 52, + 93, + 74, + 2, + 10, + 221, + 147, + 227, + 21, + 150, + 165, + 162, + 4, + 4, + 95, + 117, + 250, + 213, + 51, + 5, + 214, + 181, + 170, + 181 + ], + "ciphertext": [ + 50, + 197, + 8, + 37, + 20, + 148, + 208, + 94, + 217, + 65, + 59, + 0, + 17, + 160, + 40, + 161, + 187, + 155, + 247, + 225, + 143, + 114, + 222, + 75, + 117, + 12, + 199, + 171, + 150, + 236, + 3, + 77 + ], + "tag": [ + 39, + 201, + 148, + 104, + 8, + 16, + 247, + 181, + 56, + 195, + 123, + 85, + 27, + 47, + 23, + 223 + ] + }, + { + "key": [ + 139, + 178, + 170, + 50, + 25, + 198, + 4, + 84, + 75, + 65, + 135, + 212, + 145, + 88, + 109, + 159 + ], + "nonce": [ + 52, + 29, + 118, + 218, + 110, + 48, + 148, + 252, + 53, + 112, + 174, + 120 + ], + "aad": [ + 105, + 197, + 233, + 140, + 173, + 154, + 163, + 50, + 116, + 68, + 185, + 98, + 94, + 171, + 205, + 8, + 99, + 103, + 230, + 65, + 112, + 211, + 92, + 69, + 134, + 250, + 56, + 90, + 57, + 107, + 21, + 148, + 37, + 248, + 221, + 57, + 105, + 68, + 101, + 41, + 214, + 81, + 206, + 90, + 59, + 100, + 50, + 82, + 148, + 135, + 249, + 29, + 25, + 61, + 5, + 210, + 227, + 69, + 162, + 139, + 80, + 223, + 252, + 204, + 3, + 150, + 247, + 110, + 65, + 128, + 134, + 225, + 254, + 39, + 104, + 227, + 64, + 193, + 252, + 255, + 219, + 41, + 233, + 81, + 72, + 41, + 84, + 136, + 35, + 243 + ], + "plaintext": [ + 39, + 74, + 32, + 151, + 112, + 140, + 83, + 253, + 42, + 129, + 68, + 78, + 19, + 40, + 86, + 145, + 238, + 193, + 146, + 194, + 35, + 184, + 77, + 201, + 130, + 76, + 103, + 237, + 58, + 5, + 11, + 169 + ], + "ciphertext": [ + 237, + 135, + 117, + 0, + 31, + 51, + 186, + 253, + 177, + 239, + 87, + 118, + 152, + 17, + 110, + 154, + 230, + 86, + 8, + 95, + 202, + 139, + 150, + 151, + 64, + 199, + 198, + 151, + 69, + 15, + 152, + 121 + ], + "tag": [ + 108, + 137, + 54, + 196, + 45, + 196, + 99, + 33, + 105, + 93, + 58, + 242, + 163, + 58, + 218, + 20 + ] + }, + { + "key": [ + 77, + 129, + 84, + 66, + 109, + 27, + 18, + 234, + 249, + 141, + 9, + 172, + 5, + 177, + 249, + 228 + ], + "nonce": [ + 35, + 227, + 145, + 107, + 157, + 100, + 249, + 141, + 18, + 46, + 107, + 230 + ], + "aad": [ + 35, + 85, + 99, + 27, + 157, + 72, + 127, + 74, + 126, + 201, + 141, + 73, + 127, + 37, + 28, + 183, + 154, + 207, + 197, + 140, + 5, + 23, + 213, + 231, + 185, + 42, + 26, + 187, + 174, + 106, + 231, + 53, + 59, + 135, + 77, + 2, + 250, + 175, + 100, + 16, + 67, + 133, + 57, + 224, + 39, + 16, + 228, + 215, + 205, + 173, + 166, + 134, + 135, + 31, + 239, + 117, + 130, + 213, + 98, + 243, + 132, + 165, + 113, + 206, + 30, + 220, + 104, + 239, + 253, + 185, + 50, + 70, + 46, + 100, + 140, + 113, + 43, + 78, + 29, + 78, + 46, + 70, + 113, + 138, + 189, + 60, + 197, + 151, + 58, + 160 + ], + "plaintext": [ + 216, + 166, + 156, + 87, + 150, + 156, + 101, + 81, + 195, + 40, + 103, + 95, + 125, + 119, + 47, + 170, + 214, + 194, + 198, + 132, + 59, + 244, + 178, + 9, + 228, + 131, + 251, + 223, + 197, + 239, + 202, + 164 + ], + "ciphertext": [ + 47, + 165, + 60, + 111, + 209, + 132, + 109, + 184, + 16, + 2, + 233, + 193, + 77, + 166, + 52, + 72, + 11, + 53, + 34, + 37, + 233, + 25, + 10, + 176, + 61, + 37, + 152, + 239, + 73, + 163, + 178, + 184 + ], + "tag": [ + 164, + 2, + 63, + 216, + 208, + 240, + 118, + 238, + 213, + 153, + 47, + 104, + 11, + 21, + 68, + 51 + ] + }, + { + "key": [ + 44, + 20, + 181, + 93, + 193, + 248, + 227, + 172, + 248, + 82, + 88, + 161, + 35, + 96, + 5, + 63 + ], + "nonce": [ + 91, + 89, + 48, + 167, + 246, + 59, + 26, + 142, + 196, + 69, + 223, + 160 + ], + "aad": [ + 220, + 143, + 183, + 13, + 58, + 253, + 60, + 103, + 201, + 168, + 107, + 52, + 103, + 221, + 250, + 35, + 41, + 140, + 101, + 35, + 235, + 231, + 239, + 23, + 183, + 188, + 219, + 46, + 241, + 48, + 198, + 27, + 213, + 173, + 202, + 46, + 235, + 200, + 151, + 253, + 65, + 38, + 71, + 14, + 10, + 144, + 136, + 232, + 238, + 74, + 96, + 147, + 144, + 36, + 185, + 171, + 199, + 237, + 85, + 29, + 14, + 121, + 33, + 78, + 222, + 165, + 102, + 202, + 77, + 151, + 1, + 152, + 249, + 179, + 162, + 11, + 104, + 34, + 244, + 227, + 15, + 194, + 203, + 231, + 101, + 150, + 160, + 24, + 23, + 255 + ], + "plaintext": [ + 65, + 167, + 86, + 157, + 95, + 63, + 57, + 174, + 6, + 84, + 125, + 14, + 214, + 129, + 232, + 146, + 35, + 130, + 207, + 201, + 64, + 188, + 126, + 85, + 218, + 32, + 14, + 191, + 144, + 91, + 244, + 118 + ], + "ciphertext": [ + 246, + 67, + 100, + 238, + 21, + 172, + 240, + 73, + 216, + 191, + 144, + 170, + 169, + 20, + 191, + 250, + 233, + 172, + 96, + 115, + 184, + 213, + 97, + 34, + 39, + 110, + 254, + 4, + 178, + 2, + 208, + 249 + ], + "tag": [ + 250, + 9, + 57, + 12, + 28, + 233, + 236, + 151, + 252, + 16, + 197, + 94, + 242, + 218, + 36, + 37 + ] + }, + { + "key": [ + 89, + 65, + 87, + 236, + 70, + 147, + 32, + 43, + 3, + 15, + 51, + 121, + 139, + 7, + 23, + 109 + ], + "nonce": [ + 73, + 177, + 32, + 84, + 8, + 38, + 96, + 128, + 58, + 29, + 243, + 223 + ], + "aad": [], + "plaintext": [ + 63, + 238, + 249, + 138, + 151, + 106, + 27, + 214, + 52, + 243, + 100, + 172, + 66, + 139, + 181, + 156, + 213, + 31, + 177, + 89, + 236, + 23, + 137, + 148, + 105, + 24, + 219, + 213, + 14, + 166, + 201, + 213, + 148, + 163, + 163, + 26, + 82, + 105, + 176, + 218, + 105, + 54, + 194, + 157, + 6, + 58, + 95, + 162, + 204, + 138, + 28 + ], + "ciphertext": [ + 193, + 183, + 164, + 106, + 51, + 95, + 35, + 214, + 91, + 141, + 180, + 0, + 138, + 73, + 121, + 105, + 6, + 226, + 37, + 71, + 79, + 79, + 231, + 211, + 158, + 85, + 191, + 46, + 253, + 151, + 253, + 130, + 212, + 22, + 125, + 224, + 130, + 174, + 48, + 250, + 1, + 228, + 101, + 166, + 1, + 35, + 93, + 141, + 104, + 188, + 105 + ], + "tag": [ + 186, + 146, + 211, + 102, + 28, + 232, + 176, + 70, + 135, + 232, + 120, + 141, + 85, + 65, + 125, + 194 + ] + }, + { + "key": [ + 126, + 106, + 91, + 109, + 41, + 106, + 199, + 167, + 73, + 75, + 114, + 201, + 59, + 173, + 21, + 206 + ], + "nonce": [ + 82, + 37, + 194, + 85, + 188, + 130, + 148, + 154, + 28, + 219, + 134, + 200 + ], + "aad": [], + "plaintext": [ + 139, + 212, + 82, + 99, + 63, + 157, + 174, + 6, + 57, + 254, + 14, + 103, + 227, + 100, + 1, + 173, + 246, + 91, + 62, + 223, + 103, + 153, + 255, + 158, + 236, + 128, + 216, + 92, + 19, + 200, + 94, + 14, + 224, + 148, + 145, + 212, + 245, + 172, + 175, + 138, + 233, + 32, + 40, + 24, + 1, + 162, + 245, + 209, + 44, + 147, + 112 + ], + "ciphertext": [ + 35, + 72, + 245, + 18, + 163, + 168, + 80, + 27, + 233, + 234, + 164, + 29, + 138, + 18, + 127, + 205, + 143, + 3, + 104, + 213, + 5, + 57, + 129, + 165, + 98, + 111, + 133, + 64, + 83, + 99, + 210, + 24, + 175, + 123, + 165, + 42, + 43, + 219, + 135, + 161, + 255, + 7, + 50, + 159, + 33, + 121, + 47, + 76, + 100, + 252, + 57 + ], + "tag": [ + 135, + 83, + 206, + 224, + 32, + 172, + 102, + 142, + 158, + 26, + 55, + 246, + 50, + 49, + 84, + 62 + ] + }, + { + "key": [ + 13, + 84, + 231, + 139, + 224, + 235, + 166, + 84, + 70, + 104, + 39, + 33, + 54, + 133, + 103, + 242 + ], + "nonce": [ + 174, + 252, + 233, + 248, + 3, + 7, + 251, + 255, + 9, + 101, + 136, + 27 + ], + "aad": [], + "plaintext": [ + 91, + 51, + 91, + 233, + 122, + 134, + 200, + 193, + 162, + 155, + 116, + 8, + 131, + 63, + 117, + 44, + 140, + 93, + 76, + 145, + 46, + 127, + 38, + 199, + 59, + 144, + 146, + 57, + 225, + 34, + 47, + 200, + 81, + 180, + 227, + 192, + 172, + 204, + 81, + 72, + 204, + 96, + 175, + 47, + 1, + 159, + 158, + 224, + 6, + 1, + 49 + ], + "ciphertext": [ + 114, + 119, + 174, + 189, + 27, + 235, + 35, + 154, + 58, + 97, + 5, + 135, + 176, + 215, + 205, + 113, + 100, + 2, + 145, + 164, + 228, + 214, + 220, + 167, + 58, + 93, + 14, + 5, + 240, + 88, + 231, + 160, + 225, + 81, + 160, + 208, + 135, + 255, + 37, + 109, + 8, + 135, + 110, + 31, + 195, + 224, + 229, + 230, + 156, + 114, + 176 + ], + "tag": [ + 189, + 168, + 121, + 64, + 79, + 194, + 38, + 207, + 173, + 131, + 74, + 62, + 133, + 224, + 68, + 21 + ] + }, + { + "key": [ + 11, + 219, + 183, + 152, + 106, + 96, + 38, + 209, + 122, + 157, + 237, + 119, + 0, + 131, + 31, + 89 + ], + "nonce": [ + 227, + 189, + 186, + 47, + 227, + 181, + 202, + 215, + 39, + 7, + 18, + 2 + ], + "aad": [], + "plaintext": [ + 119, + 236, + 104, + 181, + 31, + 94, + 176, + 242, + 216, + 13, + 58, + 246, + 150, + 98, + 127, + 54, + 91, + 110, + 131, + 230, + 159, + 16, + 92, + 123, + 173, + 142, + 72, + 105, + 178, + 40, + 160, + 196, + 150, + 170, + 5, + 201, + 110, + 151, + 166, + 191, + 203, + 51, + 170, + 23, + 47, + 34, + 198, + 191, + 61, + 81, + 22 + ], + "ciphertext": [ + 231, + 165, + 167, + 1, + 233, + 80, + 202, + 38, + 152, + 126, + 28, + 64, + 200, + 137, + 180, + 117, + 219, + 165, + 12, + 234, + 19, + 240, + 158, + 157, + 59, + 195, + 207, + 76, + 132, + 56, + 44, + 21, + 189, + 228, + 195, + 79, + 240, + 94, + 178, + 120, + 180, + 183, + 69, + 229, + 28, + 191, + 79, + 18, + 193, + 38, + 137 + ], + "tag": [ + 183, + 148, + 153, + 26, + 138, + 74, + 159, + 61, + 89, + 217, + 152, + 126, + 159, + 183, + 172, + 48 + ] + }, + { + "key": [ + 130, + 62, + 133, + 46, + 240, + 185, + 85, + 27, + 39, + 0, + 190, + 214, + 94, + 220, + 200, + 8 + ], + "nonce": [ + 133, + 121, + 142, + 229, + 253, + 51, + 239, + 117, + 42, + 54, + 61, + 133 + ], + "aad": [], + "plaintext": [ + 193, + 235, + 217, + 104, + 216, + 97, + 253, + 223, + 250, + 180, + 24, + 87, + 222, + 112, + 73, + 189, + 238, + 115, + 172, + 254, + 165, + 86, + 76, + 244, + 76, + 228, + 13, + 117, + 185, + 96, + 202, + 84, + 83, + 205, + 160, + 147, + 165, + 92, + 85, + 39, + 104, + 127, + 37, + 67, + 59, + 214, + 220, + 222, + 68, + 48, + 48 + ], + "ciphertext": [ + 232, + 233, + 118, + 232, + 23, + 90, + 65, + 236, + 106, + 98, + 154, + 34, + 92, + 242, + 119, + 161, + 167, + 226, + 184, + 57, + 178, + 245, + 129, + 200, + 134, + 152, + 163, + 147, + 0, + 228, + 165, + 78, + 243, + 129, + 247, + 180, + 51, + 224, + 234, + 154, + 207, + 254, + 89, + 128, + 29, + 81, + 108, + 212, + 198, + 17, + 53 + ], + "tag": [ + 204, + 253, + 192, + 16, + 189, + 22, + 221, + 214, + 81, + 208, + 161, + 137, + 37, + 90, + 112, + 53 + ] + }, + { + "key": [ + 153, + 192, + 0, + 26, + 124, + 18, + 243, + 49, + 231, + 179, + 177, + 100, + 218, + 244, + 97, + 111 + ], + "nonce": [ + 56, + 62, + 141, + 249, + 219, + 57, + 140, + 94, + 152, + 66, + 37, + 124 + ], + "aad": [], + "plaintext": [ + 157, + 138, + 182, + 119, + 76, + 191, + 72, + 111, + 196, + 55, + 138, + 5, + 167, + 170, + 187, + 167, + 186, + 127, + 244, + 160, + 245, + 238, + 181, + 28, + 84, + 194, + 174, + 154, + 93, + 216, + 41, + 210, + 115, + 80, + 137, + 149, + 93, + 90, + 226, + 64, + 210, + 141, + 168, + 183, + 153, + 148, + 205, + 114, + 35, + 78, + 230 + ], + "ciphertext": [ + 35, + 197, + 227, + 11, + 64, + 176, + 148, + 108, + 245, + 180, + 223, + 21, + 64, + 127, + 242, + 217, + 115, + 57, + 122, + 16, + 233, + 74, + 48, + 59, + 113, + 164, + 165, + 222, + 7, + 70, + 68, + 0, + 106, + 16, + 252, + 171, + 25, + 143, + 134, + 196, + 21, + 108, + 89, + 226, + 137, + 0, + 185, + 88, + 239, + 203, + 138 + ], + "tag": [ + 142, + 205, + 97, + 150, + 19, + 121, + 5, + 38, + 55, + 41, + 218, + 252, + 6, + 134, + 7, + 32 + ] + }, + { + "key": [ + 111, + 165, + 245, + 183, + 159, + 111, + 47, + 167, + 193, + 5, + 29, + 42, + 55, + 77, + 184, + 34 + ], + "nonce": [ + 212, + 102, + 191, + 207, + 114, + 120, + 145, + 67, + 234, + 222, + 30, + 132 + ], + "aad": [], + "plaintext": [ + 217, + 82, + 136, + 86, + 219, + 8, + 120, + 73, + 38, + 74, + 200, + 17, + 104, + 148, + 32, + 239, + 43, + 238, + 169, + 198, + 118, + 118, + 68, + 243, + 202, + 139, + 252, + 99, + 69, + 163, + 226, + 229, + 196, + 158, + 126, + 15, + 217, + 177, + 194, + 225, + 103, + 27, + 209, + 182, + 39, + 91, + 11, + 212, + 51, + 6, + 197 + ], + "ciphertext": [ + 17, + 40, + 177, + 218, + 134, + 183, + 29, + 60, + 12, + 185, + 144, + 79, + 37, + 19, + 210, + 50, + 156, + 3, + 55, + 84, + 252, + 13, + 64, + 248, + 124, + 223, + 199, + 238, + 83, + 219, + 227, + 171, + 86, + 87, + 25, + 200, + 209, + 220, + 93, + 51, + 20, + 18, + 59, + 201, + 224, + 150, + 252, + 133, + 9, + 184, + 93 + ], + "tag": [ + 25, + 9, + 43, + 151, + 118, + 196, + 161, + 246, + 227, + 3, + 84, + 250, + 81, + 21, + 220, + 4 + ] + }, + { + "key": [ + 188, + 231, + 208, + 51, + 242, + 75, + 168, + 251, + 194, + 55, + 240, + 111, + 64, + 198, + 174, + 37 + ], + "nonce": [ + 192, + 214, + 137, + 6, + 233, + 135, + 254, + 34, + 52, + 76, + 174, + 82 + ], + "aad": [], + "plaintext": [ + 229, + 51, + 24, + 12, + 12, + 115, + 215, + 87, + 153, + 2, + 83, + 3, + 214, + 96, + 228, + 61, + 87, + 149, + 173, + 70, + 184, + 74, + 5, + 116, + 27, + 68, + 31, + 133, + 94, + 238, + 162, + 153, + 166, + 72, + 76, + 23, + 243, + 158, + 136, + 74, + 238, + 40, + 183, + 211, + 132, + 175, + 180, + 156, + 19, + 76, + 115 + ], + "ciphertext": [ + 71, + 35, + 218, + 165, + 22, + 185, + 32, + 236, + 3, + 157, + 216, + 192, + 112, + 74, + 55, + 240, + 187, + 173, + 147, + 64, + 167, + 233, + 135, + 136, + 141, + 177, + 32, + 69, + 156, + 57, + 204, + 6, + 149, + 84, + 99, + 138, + 182, + 179, + 44, + 255, + 88, + 94, + 213, + 142, + 45, + 124, + 24, + 8, + 34, + 151, + 118 + ], + "tag": [ + 26, + 230, + 18, + 228, + 118, + 245, + 190, + 185, + 159, + 101, + 170, + 155, + 95, + 2, + 179, + 219 + ] + }, + { + "key": [ + 247, + 138, + 5, + 205, + 38, + 33, + 233, + 56, + 92, + 161, + 17, + 243, + 161, + 104, + 253, + 171 + ], + "nonce": [ + 161, + 106, + 239, + 131, + 219, + 189, + 95, + 105, + 194, + 86, + 145, + 3 + ], + "aad": [], + "plaintext": [ + 158, + 118, + 29, + 75, + 123, + 220, + 226, + 184, + 81, + 229, + 8, + 247, + 127, + 175, + 68, + 127, + 248, + 53, + 5, + 117, + 84, + 148, + 241, + 187, + 81, + 105, + 220, + 35, + 187, + 2, + 217, + 186, + 143, + 184, + 180, + 135, + 140, + 138, + 71, + 223, + 209, + 78, + 160, + 220, + 239, + 62, + 131, + 198, + 136, + 229, + 151 + ], + "ciphertext": [ + 126, + 173, + 107, + 222, + 150, + 76, + 53, + 252, + 245, + 222, + 35, + 241, + 151, + 37, + 56, + 118, + 1, + 247, + 5, + 172, + 17, + 197, + 254, + 31, + 197, + 49, + 116, + 107, + 242, + 216, + 113, + 253, + 165, + 66, + 100, + 166, + 35, + 199, + 14, + 114, + 181, + 181, + 236, + 173, + 196, + 67, + 79, + 158, + 105, + 111, + 252 + ], + "tag": [ + 47, + 19, + 228, + 189, + 152, + 131, + 199, + 71, + 240, + 199, + 156, + 145, + 230, + 97, + 170, + 143 + ] + }, + { + "key": [ + 220, + 27, + 133, + 105, + 168, + 4, + 110, + 63, + 41, + 76, + 60, + 202, + 1, + 143, + 102, + 19 + ], + "nonce": [ + 91, + 60, + 187, + 224, + 233, + 72, + 219, + 142, + 254, + 66, + 6, + 46 + ], + "aad": [], + "plaintext": [ + 106, + 58, + 26, + 152, + 21, + 105, + 1, + 6, + 209, + 144, + 139, + 199, + 230, + 62, + 37, + 191, + 216, + 1, + 144, + 14, + 148, + 169, + 251, + 194, + 139, + 109, + 82, + 184, + 249, + 180, + 222, + 112, + 3, + 176, + 102, + 187, + 177, + 139, + 186, + 51, + 218, + 131, + 198, + 120, + 9, + 227, + 188, + 249, + 139, + 92, + 188 + ], + "ciphertext": [ + 176, + 42, + 37, + 58, + 23, + 251, + 146, + 72, + 39, + 124, + 174, + 3, + 5, + 71, + 56, + 112, + 193, + 158, + 112, + 183, + 147, + 10, + 11, + 233, + 190, + 144, + 84, + 35, + 71, + 148, + 19, + 219, + 227, + 112, + 47, + 66, + 2, + 77, + 105, + 71, + 100, + 21, + 41, + 11, + 20, + 34, + 242, + 192, + 48, + 233, + 158 + ], + "tag": [ + 240, + 251, + 133, + 227, + 214, + 179, + 165, + 221, + 197, + 218, + 62, + 199, + 151, + 247, + 88, + 221 + ] + }, + { + "key": [ + 206, + 190, + 241, + 84, + 179, + 202, + 33, + 103, + 35, + 13, + 175, + 59, + 130, + 5, + 241, + 30 + ], + "nonce": [ + 224, + 220, + 35, + 170, + 80, + 165, + 44, + 174, + 100, + 72, + 116, + 176 + ], + "aad": [], + "plaintext": [ + 184, + 203, + 7, + 14, + 191, + 91, + 39, + 165, + 31, + 20, + 242, + 44, + 107, + 56, + 252, + 41, + 208, + 76, + 67, + 28, + 72, + 76, + 17, + 122, + 210, + 80, + 236, + 79, + 151, + 252, + 77, + 244, + 75, + 14, + 200, + 71, + 182, + 154, + 54, + 57, + 99, + 212, + 25, + 206, + 154, + 209, + 26, + 50, + 22, + 134, + 176 + ], + "ciphertext": [ + 76, + 9, + 24, + 232, + 107, + 21, + 43, + 226, + 196, + 223, + 227, + 108, + 120, + 184, + 165, + 89, + 194, + 199, + 248, + 63, + 167, + 119, + 109, + 3, + 65, + 49, + 138, + 6, + 92, + 42, + 47, + 27, + 38, + 120, + 170, + 175, + 247, + 108, + 173, + 48, + 204, + 170, + 29, + 205, + 3, + 165, + 187, + 22, + 208, + 15, + 63 + ], + "tag": [ + 121, + 38, + 123, + 223, + 112, + 231, + 78, + 170, + 1, + 30, + 136, + 147, + 105, + 245, + 131, + 29 + ] + }, + { + "key": [ + 215, + 233, + 81, + 9, + 18, + 126, + 131, + 180, + 212, + 60, + 129, + 215, + 239, + 109, + 89, + 114 + ], + "nonce": [ + 67, + 172, + 13, + 136, + 149, + 237, + 120, + 94, + 44, + 182, + 157, + 72 + ], + "aad": [], + "plaintext": [ + 178, + 96, + 31, + 33, + 107, + 94, + 111, + 96, + 197, + 24, + 220, + 129, + 124, + 56, + 190, + 148, + 10, + 192, + 59, + 171, + 242, + 230, + 245, + 221, + 202, + 8, + 116, + 232, + 25, + 249, + 170, + 190, + 4, + 100, + 96, + 227, + 204, + 246, + 81, + 21, + 102, + 187, + 222, + 45, + 155, + 25, + 31, + 193, + 106, + 196, + 182 + ], + "ciphertext": [ + 149, + 126, + 113, + 45, + 195, + 74, + 216, + 145, + 205, + 179, + 173, + 204, + 230, + 43, + 4, + 84, + 234, + 233, + 199, + 146, + 230, + 78, + 180, + 224, + 134, + 36, + 222, + 16, + 48, + 137, + 204, + 25, + 73, + 151, + 73, + 232, + 174, + 109, + 140, + 146, + 226, + 192, + 76, + 92, + 179, + 110, + 240, + 151, + 187, + 0, + 221 + ], + "tag": [ + 245, + 105, + 86, + 44, + 185, + 72, + 40, + 254, + 113, + 251, + 221, + 207, + 217, + 132, + 186, + 229 + ] + }, + { + "key": [ + 57, + 171, + 120, + 25, + 219, + 249, + 68, + 204, + 205, + 38, + 72, + 68, + 83, + 55, + 21, + 143 + ], + "nonce": [ + 69, + 148, + 132, + 14, + 5, + 195, + 59, + 219, + 192, + 24, + 113, + 116 + ], + "aad": [], + "plaintext": [ + 131, + 76, + 176, + 86, + 129, + 233, + 167, + 135, + 107, + 202, + 137, + 30, + 183, + 130, + 67, + 146, + 199, + 172, + 41, + 212, + 255, + 76, + 154, + 138, + 217, + 100, + 71, + 210, + 204, + 95, + 15, + 242, + 24, + 4, + 61, + 53, + 16, + 32, + 20, + 82, + 186, + 92, + 120, + 155, + 162, + 166, + 103, + 188, + 247, + 155, + 156 + ], + "ciphertext": [ + 54, + 42, + 207, + 121, + 223, + 40, + 195, + 200, + 88, + 233, + 44, + 12, + 95, + 10, + 50, + 59, + 62, + 162, + 232, + 27, + 230, + 124, + 253, + 144, + 58, + 98, + 126, + 209, + 99, + 192, + 99, + 147, + 40, + 123, + 115, + 254, + 51, + 164, + 53, + 185, + 102, + 114, + 185, + 191, + 26, + 90, + 44, + 44, + 255, + 74, + 21 + ], + "tag": [ + 229, + 138, + 48, + 226, + 201, + 30, + 109, + 37, + 244, + 35, + 171, + 222, + 152, + 124, + 242, + 247 + ] + }, + { + "key": [ + 115, + 56, + 143, + 131, + 228, + 9, + 234, + 35, + 97, + 41, + 228, + 109, + 201, + 169, + 178, + 11 + ], + "nonce": [ + 169, + 6, + 155, + 0, + 225, + 205, + 41, + 162, + 176, + 123, + 141, + 182 + ], + "aad": [], + "plaintext": [ + 162, + 225, + 56, + 213, + 97, + 28, + 80, + 67, + 33, + 79, + 125, + 159, + 156, + 135, + 170, + 185, + 78, + 11, + 142, + 153, + 179, + 17, + 208, + 202, + 233, + 8, + 41, + 7, + 140, + 56, + 152, + 200, + 255, + 250, + 125, + 233, + 120, + 154, + 240, + 166, + 192, + 95, + 55, + 91, + 47, + 113, + 13, + 212, + 186, + 38, + 16 + ], + "ciphertext": [ + 119, + 224, + 250, + 107, + 39, + 101, + 66, + 138, + 228, + 24, + 181, + 126, + 207, + 90, + 57, + 34, + 48, + 250, + 42, + 155, + 209, + 104, + 107, + 145, + 223, + 105, + 132, + 92, + 250, + 10, + 45, + 217, + 173, + 210, + 25, + 34, + 158, + 101, + 255, + 106, + 47, + 136, + 123, + 120, + 235, + 232, + 192, + 197, + 209, + 190, + 33 + ], + "tag": [ + 50, + 56, + 92, + 237, + 25, + 90, + 22, + 218, + 213, + 238, + 165, + 161, + 159, + 208, + 250, + 67 + ] + }, + { + "key": [ + 213, + 144, + 229, + 59, + 105, + 83, + 21, + 204, + 11, + 145, + 125, + 159, + 160, + 170, + 198, + 67 + ], + "nonce": [ + 16, + 45, + 231, + 223, + 70, + 26, + 85, + 120, + 231, + 92, + 73, + 117 + ], + "aad": [], + "plaintext": [ + 126, + 230, + 49, + 251, + 104, + 93, + 74, + 148, + 86, + 62, + 1, + 72, + 14, + 197, + 82, + 109, + 4, + 164, + 3, + 93, + 31, + 97, + 95, + 219, + 173, + 102, + 86, + 226, + 73, + 95, + 229, + 215, + 240, + 214, + 196, + 13, + 255, + 101, + 159, + 200, + 95, + 76, + 205, + 120, + 67, + 58, + 25, + 35, + 19, + 195, + 212 + ], + "ciphertext": [ + 225, + 50, + 45, + 12, + 146, + 101, + 205, + 119, + 77, + 46, + 157, + 155, + 103, + 113, + 121, + 150, + 0, + 183, + 155, + 163, + 131, + 116, + 238, + 23, + 86, + 170, + 104, + 113, + 226, + 4, + 229, + 246, + 135, + 28, + 213, + 13, + 177, + 82, + 37, + 222, + 214, + 74, + 156, + 136, + 153, + 186, + 179, + 114, + 136, + 167, + 146 + ], + "tag": [ + 19, + 230, + 6, + 169, + 164, + 199, + 134, + 182, + 94, + 34, + 96, + 205, + 218, + 75, + 24, + 67 + ] + }, + { + "key": [ + 182, + 21, + 83, + 187, + 133, + 72, + 149, + 185, + 41, + 117, + 28, + 208, + 197, + 248, + 3, + 132 + ], + "nonce": [ + 136, + 99, + 249, + 153, + 174, + 100, + 229, + 93, + 11, + 189, + 116, + 87 + ], + "aad": [ + 217, + 20, + 181, + 242, + 209, + 176, + 140, + 229, + 62, + 165, + 156, + 179, + 16, + 88, + 114, + 69 + ], + "plaintext": [ + 155, + 27, + 17, + 50, + 23, + 208, + 196, + 234, + 121, + 67, + 207, + 18, + 60, + 105, + 198, + 173, + 46, + 60, + 151, + 54, + 140, + 81, + 201, + 117, + 65, + 69, + 209, + 85, + 221, + 225, + 238, + 134, + 64, + 200, + 202, + 255, + 241, + 122, + 92, + 151, + 55, + 210, + 106, + 19, + 126, + 238, + 75, + 243, + 105, + 9, + 109 + ], + "ciphertext": [ + 172, + 250, + 180, + 99, + 43, + 138, + 37, + 128, + 81, + 18, + 241, + 61, + 133, + 224, + 130, + 188, + 137, + 220, + 73, + 189, + 146, + 22, + 79, + 168, + 162, + 218, + 210, + 66, + 195, + 161, + 178, + 242, + 105, + 111, + 47, + 223, + 245, + 121, + 2, + 95, + 63, + 20, + 110, + 169, + 125, + 163, + 228, + 125, + 195, + 75, + 101 + ], + "tag": [ + 93, + 155, + 95, + 74, + 152, + 104, + 193, + 198, + 156, + 189, + 111, + 216, + 81, + 240, + 19, + 64 + ] + }, + { + "key": [ + 67, + 36, + 201, + 123, + 168, + 201, + 242, + 161, + 189, + 68, + 123, + 222, + 94, + 117, + 147, + 141 + ], + "nonce": [ + 188, + 172, + 104, + 16, + 106, + 63, + 194, + 32, + 72, + 70, + 43, + 201 + ], + "aad": [ + 42, + 137, + 62, + 236, + 46, + 238, + 244, + 194, + 233, + 195, + 5, + 66, + 139, + 158, + 50, + 147 + ], + "plaintext": [ + 120, + 159, + 193, + 75, + 125, + 78, + 200, + 62, + 199, + 131, + 192, + 239, + 56, + 250, + 166, + 112, + 96, + 49, + 173, + 228, + 230, + 90, + 233, + 31, + 14, + 28, + 87, + 155, + 140, + 134, + 82, + 233, + 78, + 4, + 196, + 238, + 93, + 133, + 210, + 61, + 5, + 37, + 193, + 51, + 169, + 58, + 149, + 57, + 68, + 140, + 161 + ], + "ciphertext": [ + 43, + 167, + 33, + 222, + 26, + 167, + 175, + 186, + 105, + 205, + 15, + 164, + 146, + 252, + 173, + 95, + 230, + 57, + 216, + 85, + 193, + 242, + 128, + 128, + 43, + 156, + 213, + 223, + 243, + 127, + 75, + 245, + 74, + 17, + 123, + 143, + 64, + 12, + 182, + 57, + 6, + 163, + 199, + 140, + 220, + 26, + 233, + 139, + 12, + 48, + 209 + ], + "tag": [ + 23, + 29, + 242, + 99, + 167, + 34, + 82, + 242, + 196, + 79, + 90, + 99, + 240, + 137, + 173, + 177 + ] + }, + { + "key": [ + 81, + 228, + 44, + 235, + 131, + 23, + 93, + 29, + 240, + 155, + 131, + 133, + 168, + 79, + 189, + 239 + ], + "nonce": [ + 236, + 107, + 127, + 33, + 219, + 110, + 177, + 108, + 232, + 127, + 137, + 176 + ], + "aad": [ + 58, + 8, + 27, + 87, + 52, + 83, + 115, + 5, + 34, + 47, + 49, + 78, + 243, + 154, + 141, + 32 + ], + "plaintext": [ + 76, + 90, + 52, + 176, + 172, + 200, + 116, + 95, + 69, + 192, + 77, + 108, + 130, + 113, + 107, + 131, + 236, + 107, + 229, + 20, + 109, + 18, + 114, + 131, + 94, + 166, + 66, + 180, + 159, + 85, + 53, + 63, + 188, + 114, + 163, + 172, + 209, + 102, + 36, + 229, + 55, + 124, + 186, + 181, + 78, + 53, + 110, + 58, + 246, + 190, + 1 + ], + "ciphertext": [ + 27, + 75, + 183, + 15, + 62, + 211, + 143, + 55, + 142, + 41, + 237, + 183, + 230, + 80, + 129, + 247, + 148, + 114, + 90, + 3, + 64, + 218, + 236, + 87, + 8, + 161, + 99, + 163, + 168, + 18, + 114, + 172, + 43, + 212, + 179, + 227, + 219, + 143, + 138, + 213, + 125, + 87, + 27, + 94, + 178, + 74, + 246, + 82, + 227, + 200, + 126 + ], + "tag": [ + 106, + 159, + 42, + 75, + 115, + 41, + 15, + 197, + 102, + 243, + 124, + 40, + 104, + 135, + 237, + 237 + ] + }, + { + "key": [ + 146, + 128, + 224, + 90, + 97, + 77, + 69, + 47, + 64, + 122, + 171, + 105, + 106, + 250, + 213, + 47 + ], + "nonce": [ + 9, + 158, + 240, + 41, + 34, + 89, + 34, + 84, + 228, + 69, + 23, + 205 + ], + "aad": [ + 18, + 220, + 77, + 166, + 35, + 208, + 130, + 199, + 103, + 163, + 247, + 239, + 233, + 166, + 235, + 201 + ], + "plaintext": [ + 219, + 145, + 16, + 141, + 71, + 242, + 102, + 221, + 147, + 113, + 105, + 139, + 25, + 75, + 58, + 24, + 63, + 41, + 54, + 120, + 43, + 228, + 23, + 207, + 26, + 4, + 140, + 101, + 4, + 22, + 45, + 55, + 225, + 26, + 65, + 227, + 187, + 254, + 185, + 143, + 153, + 94, + 200, + 227, + 93, + 233, + 75, + 255, + 224, + 163, + 99 + ], + "ciphertext": [ + 138, + 192, + 112, + 171, + 151, + 82, + 24, + 175, + 12, + 34, + 67, + 81, + 116, + 171, + 202, + 176, + 26, + 245, + 219, + 153, + 23, + 9, + 94, + 103, + 20, + 11, + 49, + 254, + 235, + 120, + 183, + 213, + 190, + 49, + 134, + 180, + 252, + 65, + 241, + 6, + 48, + 58, + 81, + 155, + 90, + 50, + 57, + 157, + 45, + 231, + 123 + ], + "tag": [ + 120, + 17, + 180, + 133, + 19, + 217, + 188, + 241, + 153, + 155, + 82, + 48, + 68, + 146, + 176, + 173 + ] + }, + { + "key": [ + 137, + 190, + 60, + 9, + 174, + 126, + 46, + 255, + 91, + 99, + 249, + 19, + 170, + 139, + 87, + 92 + ], + "nonce": [ + 68, + 157, + 133, + 45, + 101, + 88, + 81, + 133, + 188, + 66, + 152, + 242 + ], + "aad": [ + 210, + 50, + 113, + 60, + 43, + 2, + 75, + 90, + 255, + 212, + 161, + 80, + 80, + 220, + 186, + 65 + ], + "plaintext": [ + 147, + 204, + 245, + 217, + 7, + 222, + 169, + 176, + 254, + 213, + 80, + 127, + 138, + 38, + 64, + 13, + 10, + 86, + 140, + 14, + 245, + 59, + 159, + 166, + 191, + 157, + 104, + 2, + 178, + 15, + 230, + 114, + 201, + 169, + 83, + 111, + 199, + 91, + 133, + 240, + 142, + 77, + 44, + 69, + 207, + 3, + 36, + 34, + 243, + 14, + 169 + ], + "ciphertext": [ + 91, + 56, + 6, + 157, + 105, + 91, + 118, + 166, + 9, + 49, + 142, + 147, + 205, + 230, + 226, + 57, + 70, + 90, + 197, + 34, + 100, + 1, + 124, + 62, + 81, + 105, + 189, + 219, + 218, + 13, + 42, + 199, + 110, + 240, + 69, + 26, + 58, + 57, + 208, + 126, + 142, + 141, + 163, + 176, + 205, + 46, + 232, + 8, + 145, + 43, + 76 + ], + "tag": [ + 227, + 22, + 230, + 3, + 47, + 255, + 86, + 229, + 36, + 44, + 170, + 27, + 78, + 242, + 187, + 110 + ] + }, + { + "key": [ + 4, + 203, + 247, + 219, + 235, + 169, + 6, + 225, + 208, + 232, + 169, + 141, + 121, + 110, + 134, + 19 + ], + "nonce": [ + 181, + 128, + 89, + 19, + 148, + 41, + 166, + 166, + 163, + 140, + 203, + 7 + ], + "aad": [ + 117, + 50, + 198, + 35, + 123, + 161, + 218, + 139, + 153, + 196, + 160, + 145, + 197, + 21, + 158, + 180 + ], + "plaintext": [ + 136, + 144, + 198, + 58, + 183, + 48, + 217, + 19, + 94, + 25, + 202, + 58, + 218, + 53, + 179, + 74, + 45, + 91, + 217, + 244, + 150, + 141, + 96, + 232, + 198, + 91, + 244, + 63, + 13, + 109, + 239, + 125, + 228, + 114, + 194, + 107, + 137, + 175, + 158, + 93, + 110, + 72, + 193, + 37, + 216, + 75, + 15, + 239, + 125, + 25, + 78 + ], + "ciphertext": [ + 82, + 188, + 11, + 225, + 146, + 10, + 79, + 31, + 179, + 186, + 63, + 159, + 195, + 231, + 150, + 156, + 117, + 228, + 15, + 173, + 225, + 99, + 137, + 116, + 40, + 244, + 159, + 197, + 43, + 111, + 239, + 251, + 97, + 182, + 83, + 68, + 171, + 58, + 201, + 149, + 224, + 125, + 213, + 246, + 21, + 194, + 75, + 68, + 125, + 249, + 167 + ], + "tag": [ + 35, + 155, + 96, + 81, + 143, + 60, + 53, + 178, + 76, + 37, + 87, + 84, + 145, + 121, + 253, + 54 + ] + }, + { + "key": [ + 143, + 28, + 112, + 19, + 104, + 82, + 220, + 39, + 174, + 81, + 98, + 184, + 116, + 60, + 144, + 234 + ], + "nonce": [ + 211, + 114, + 249, + 43, + 12, + 240, + 48, + 170, + 176, + 66, + 166, + 250 + ], + "aad": [ + 126, + 239, + 245, + 209, + 126, + 121, + 240, + 13, + 104, + 226, + 108, + 183, + 230, + 190, + 231, + 108 + ], + "plaintext": [ + 11, + 100, + 70, + 175, + 136, + 196, + 85, + 215, + 241, + 255, + 81, + 22, + 199, + 175, + 148, + 152, + 3, + 204, + 80, + 188, + 241, + 236, + 252, + 129, + 198, + 98, + 113, + 65, + 164, + 43, + 54, + 63, + 126, + 183, + 252, + 98, + 133, + 3, + 187, + 111, + 3, + 125, + 174, + 132, + 63, + 210, + 211, + 25, + 182, + 17, + 24 + ], + "ciphertext": [ + 79, + 35, + 95, + 108, + 194, + 192, + 71, + 74, + 181, + 5, + 87, + 226, + 207, + 97, + 42, + 176, + 159, + 252, + 133, + 151, + 93, + 224, + 130, + 185, + 203, + 150, + 73, + 165, + 34, + 184, + 164, + 127, + 36, + 225, + 178, + 196, + 143, + 60, + 213, + 125, + 206, + 73, + 84, + 43, + 211, + 86, + 15, + 229, + 228, + 75, + 202 + ], + "tag": [ + 197, + 65, + 183, + 130, + 68, + 239, + 210, + 185, + 230, + 30, + 117, + 41, + 111, + 22, + 74, + 173 + ] + }, + { + "key": [ + 26, + 198, + 154, + 53, + 247, + 73, + 198, + 93, + 93, + 39, + 236, + 16, + 155, + 88, + 243, + 54 + ], + "nonce": [ + 240, + 185, + 198, + 232, + 207, + 199, + 186, + 76, + 136, + 13, + 153, + 168 + ], + "aad": [ + 37, + 29, + 117, + 214, + 154, + 182, + 79, + 19, + 99, + 239, + 234, + 167, + 113, + 243, + 220, + 1 + ], + "plaintext": [ + 150, + 149, + 80, + 123, + 148, + 72, + 101, + 88, + 127, + 39, + 57, + 92, + 116, + 70, + 138, + 246, + 168, + 69, + 113, + 107, + 52, + 219, + 97, + 228, + 55, + 183, + 125, + 1, + 7, + 56, + 123, + 63, + 218, + 88, + 28, + 70, + 107, + 109, + 244, + 9, + 72, + 218, + 53, + 144, + 107, + 119, + 255, + 142, + 208, + 148, + 2 + ], + "ciphertext": [ + 244, + 29, + 199, + 64, + 39, + 104, + 112, + 93, + 190, + 59, + 247, + 205, + 190, + 180, + 252, + 103, + 45, + 58, + 108, + 61, + 101, + 82, + 13, + 171, + 48, + 130, + 114, + 125, + 255, + 8, + 75, + 110, + 11, + 171, + 23, + 249, + 108, + 43, + 19, + 122, + 75, + 213, + 100, + 161, + 63, + 119, + 238, + 55, + 52, + 115, + 131 + ], + "tag": [ + 2, + 46, + 223, + 116, + 55, + 180, + 22, + 83, + 219, + 59, + 242, + 71, + 154, + 158, + 116, + 161 + ] + }, + { + "key": [ + 22, + 203, + 253, + 200, + 249, + 144, + 15, + 103, + 2, + 164, + 48, + 176, + 216, + 182, + 36, + 207 + ], + "nonce": [ + 40, + 221, + 92, + 70, + 224, + 54, + 128, + 242, + 192, + 26, + 123, + 186 + ], + "aad": [ + 177, + 188, + 189, + 210, + 124, + 14, + 244, + 222, + 70, + 47, + 206, + 11, + 232, + 133, + 90, + 54 + ], + "plaintext": [ + 225, + 86, + 45, + 110, + 106, + 70, + 156, + 253, + 159, + 10, + 106, + 21, + 190, + 154, + 3, + 60, + 212, + 84, + 149, + 158, + 248, + 179, + 123, + 45, + 165, + 129, + 100, + 255, + 241, + 216, + 219, + 211, + 250, + 194, + 185, + 123, + 241, + 181, + 3, + 4, + 111, + 217, + 204, + 104, + 188, + 148, + 45, + 15, + 114, + 122, + 60 + ], + "ciphertext": [ + 16, + 145, + 95, + 248, + 123, + 128, + 228, + 45, + 84, + 137, + 80, + 229, + 63, + 246, + 100, + 42, + 212, + 74, + 250, + 105, + 81, + 117, + 210, + 76, + 155, + 81, + 151, + 246, + 76, + 21, + 87, + 14, + 190, + 11, + 201, + 105, + 192, + 37, + 27, + 233, + 64, + 180, + 40, + 137, + 70, + 76, + 245, + 98, + 195, + 225, + 164 + ], + "tag": [ + 249, + 96, + 111, + 122, + 14, + 65, + 21, + 58, + 27, + 69, + 194, + 95, + 23, + 132, + 202, + 206 + ] + }, + { + "key": [ + 76, + 18, + 165, + 74, + 167, + 187, + 122, + 12, + 12, + 121, + 136, + 52, + 243, + 155, + 63, + 168 + ], + "nonce": [ + 229, + 133, + 79, + 172, + 154, + 220, + 163, + 187, + 27, + 197, + 73, + 183 + ], + "aad": [ + 127, + 66, + 167, + 121, + 30, + 112, + 83, + 69, + 136, + 143, + 0, + 87, + 59, + 233, + 137, + 128 + ], + "plaintext": [ + 126, + 127, + 229, + 143, + 159, + 19, + 144, + 122, + 105, + 75, + 71, + 240, + 83, + 201, + 39, + 12, + 46, + 77, + 115, + 181, + 38, + 66, + 167, + 20, + 70, + 148, + 58, + 92, + 95, + 62, + 47, + 205, + 85, + 75, + 55, + 109, + 210, + 245, + 73, + 170, + 126, + 7, + 55, + 182, + 44, + 100, + 20, + 245, + 66, + 187, + 162 + ], + "ciphertext": [ + 223, + 70, + 215, + 81, + 153, + 16, + 137, + 155, + 124, + 61, + 158, + 125, + 13, + 171, + 130, + 201, + 59, + 125, + 142, + 224, + 63, + 79, + 90, + 168, + 46, + 207, + 100, + 202, + 207, + 60, + 159, + 181, + 143, + 23, + 160, + 33, + 83, + 96, + 40, + 116, + 78, + 65, + 39, + 112, + 229, + 117, + 98, + 36, + 158, + 95, + 9 + ], + "tag": [ + 40, + 35, + 212, + 181, + 156, + 248, + 248, + 131, + 123, + 235, + 213, + 239, + 223, + 185, + 41, + 41 + ] + }, + { + "key": [ + 50, + 172, + 237, + 84, + 20, + 226, + 103, + 207, + 119, + 132, + 76, + 10, + 203, + 184, + 135, + 44 + ], + "nonce": [ + 61, + 16, + 142, + 145, + 45, + 83, + 184, + 142, + 13, + 255, + 157, + 108 + ], + "aad": [ + 123, + 228, + 197, + 223, + 121, + 53, + 69, + 61, + 80, + 241, + 198, + 199, + 154, + 230, + 193, + 58 + ], + "plaintext": [ + 199, + 252, + 245, + 60, + 147, + 165, + 33, + 198, + 226, + 68, + 242, + 3, + 207, + 196, + 11, + 128, + 189, + 138, + 177, + 228, + 229, + 76, + 219, + 88, + 31, + 193, + 76, + 49, + 220, + 106, + 147, + 128, + 94, + 219, + 186, + 50, + 167, + 41, + 172, + 241, + 167, + 192, + 76, + 139, + 3, + 102, + 194, + 3, + 92, + 101, + 179 + ], + "ciphertext": [ + 128, + 190, + 236, + 140, + 32, + 199, + 233, + 81, + 76, + 56, + 172, + 110, + 55, + 117, + 222, + 32, + 103, + 84, + 67, + 60, + 177, + 215, + 200, + 155, + 190, + 251, + 51, + 177, + 180, + 18, + 69, + 224, + 209, + 186, + 247, + 204, + 135, + 11, + 31, + 30, + 195, + 135, + 242, + 221, + 237, + 62, + 15, + 71, + 158, + 241, + 96 + ], + "tag": [ + 217, + 127, + 125, + 130, + 179, + 255, + 151, + 242, + 246, + 198, + 82, + 25, + 76, + 0, + 71, + 72 + ] + }, + { + "key": [ + 98, + 117, + 39, + 9, + 82, + 38, + 63, + 95, + 0, + 139, + 22, + 242, + 69, + 108, + 125, + 220 + ], + "nonce": [ + 29, + 24, + 55, + 234, + 76, + 179, + 115, + 42, + 110, + 166, + 72, + 125 + ], + "aad": [ + 110, + 232, + 237, + 46, + 210, + 65, + 241, + 215, + 206, + 229, + 92, + 166, + 112, + 1, + 114, + 155 + ], + "plaintext": [ + 253, + 77, + 226, + 138, + 24, + 163, + 222, + 59, + 150, + 96, + 172, + 240, + 142, + 234, + 196, + 14, + 25, + 43, + 119, + 197, + 38, + 76, + 128, + 101, + 28, + 40, + 98, + 142, + 97, + 195, + 145, + 111, + 122, + 192, + 61, + 132, + 154, + 227, + 156, + 152, + 26, + 40, + 8, + 134, + 106, + 130, + 146, + 116, + 106, + 71, + 147 + ], + "ciphertext": [ + 214, + 148, + 144, + 112, + 136, + 147, + 241, + 99, + 138, + 213, + 148, + 195, + 160, + 173, + 142, + 180, + 241, + 125, + 163, + 32, + 59, + 24, + 172, + 237, + 147, + 9, + 118, + 238, + 26, + 191, + 77, + 241, + 174, + 138, + 118, + 141, + 220, + 157, + 246, + 204, + 220, + 162, + 213, + 121, + 22, + 80, + 35, + 229, + 43, + 185, + 215 + ], + "tag": [ + 170, + 71, + 205, + 163, + 146, + 143, + 122, + 46, + 164, + 47, + 234, + 228, + 223, + 176, + 128, + 15 + ] + }, + { + "key": [ + 119, + 150, + 212, + 121, + 188, + 178, + 19, + 241, + 158, + 46, + 215, + 62, + 241, + 6, + 159, + 230 + ], + "nonce": [ + 240, + 235, + 182, + 251, + 29, + 246, + 0, + 105, + 176, + 10, + 52, + 199 + ], + "aad": [ + 135, + 86, + 59, + 77, + 114, + 226, + 242, + 192, + 9, + 75, + 255, + 103, + 142, + 59, + 121, + 117 + ], + "plaintext": [ + 247, + 38, + 3, + 182, + 231, + 75, + 175, + 194, + 15, + 66, + 59, + 234, + 42, + 16, + 54, + 171, + 68, + 70, + 27, + 94, + 90, + 86, + 49, + 176, + 19, + 87, + 61, + 149, + 62, + 31, + 176, + 115, + 184, + 85, + 81, + 24, + 96, + 209, + 120, + 44, + 31, + 59, + 20, + 107, + 92, + 65, + 235, + 148, + 110, + 47, + 202 + ], + "ciphertext": [ + 68, + 196, + 215, + 186, + 42, + 241, + 190, + 34, + 218, + 166, + 53, + 43, + 88, + 191, + 140, + 218, + 40, + 153, + 155, + 195, + 60, + 66, + 15, + 136, + 129, + 0, + 23, + 25, + 254, + 99, + 154, + 158, + 158, + 92, + 72, + 223, + 18, + 15, + 124, + 190, + 115, + 175, + 76, + 21, + 19, + 166, + 55, + 185, + 222, + 51, + 232 + ], + "tag": [ + 139, + 112, + 2, + 33, + 159, + 88, + 99, + 24, + 21, + 1, + 50, + 224, + 229, + 203, + 242, + 233 + ] + }, + { + "key": [ + 247, + 197, + 15, + 41, + 71, + 159, + 240, + 249, + 148, + 90, + 185, + 223, + 86, + 135, + 46, + 170 + ], + "nonce": [ + 27, + 185, + 77, + 123, + 57, + 158, + 183, + 169, + 160, + 239, + 175, + 110 + ], + "aad": [ + 136, + 169, + 248, + 16, + 120, + 214, + 160, + 130, + 12, + 86, + 197, + 130, + 163, + 3, + 51, + 185 + ], + "plaintext": [ + 250, + 134, + 105, + 27, + 116, + 100, + 36, + 179, + 66, + 109, + 217, + 206, + 140, + 240, + 241, + 50, + 222, + 92, + 87, + 94, + 0, + 23, + 1, + 50, + 76, + 167, + 206, + 71, + 77, + 88, + 19, + 161, + 153, + 4, + 89, + 16, + 85, + 252, + 127, + 52, + 62, + 32, + 208, + 244, + 201, + 33, + 24, + 177, + 76, + 231, + 116 + ], + "ciphertext": [ + 85, + 2, + 79, + 197, + 233, + 94, + 95, + 124, + 51, + 191, + 148, + 140, + 22, + 123, + 19, + 56, + 34, + 54, + 178, + 207, + 24, + 124, + 192, + 158, + 55, + 220, + 224, + 67, + 246, + 41, + 63, + 228, + 87, + 161, + 221, + 231, + 40, + 207, + 64, + 124, + 112, + 45, + 117, + 166, + 112, + 57, + 127, + 254, + 40, + 232, + 186 + ], + "tag": [ + 100, + 92, + 166, + 12, + 252, + 128, + 70, + 160, + 37, + 63, + 67, + 142, + 105, + 184, + 228, + 124 + ] + }, + { + "key": [ + 243, + 227, + 2, + 161, + 86, + 138, + 83, + 64, + 181, + 116, + 90, + 232, + 127, + 90, + 91, + 234 + ], + "nonce": [ + 206, + 65, + 244, + 54, + 242, + 232, + 70, + 67, + 246, + 115, + 96, + 62 + ], + "aad": [ + 135, + 186, + 54, + 210, + 52, + 236, + 80, + 139, + 48, + 143, + 242, + 88, + 198, + 189, + 66, + 123 + ], + "plaintext": [ + 228, + 171, + 170, + 102, + 135, + 91, + 216, + 212, + 91, + 110, + 213, + 231, + 103, + 27, + 3, + 224, + 148, + 35, + 234, + 65, + 183, + 216, + 144, + 57, + 218, + 146, + 114, + 129, + 81, + 189, + 105, + 12, + 205, + 239, + 79, + 161, + 99, + 146, + 167, + 248, + 94, + 252, + 11, + 194, + 177, + 102, + 75, + 211, + 241, + 94, + 119 + ], + "ciphertext": [ + 18, + 59, + 105, + 178, + 208, + 241, + 9, + 52, + 218, + 63, + 219, + 92, + 27, + 150, + 180, + 255, + 200, + 255, + 193, + 68, + 96, + 136, + 182, + 52, + 179, + 142, + 20, + 94, + 109, + 217, + 142, + 143, + 234, + 23, + 33, + 75, + 92, + 145, + 54, + 240, + 57, + 87, + 125, + 68, + 147, + 184, + 188, + 249, + 53, + 174, + 25 + ], + "tag": [ + 151, + 202, + 140, + 240, + 100, + 164, + 8, + 199, + 183, + 100, + 207, + 50, + 211, + 183, + 156, + 10 + ] + }, + { + "key": [ + 254, + 71, + 252, + 206, + 95, + 195, + 38, + 101, + 210, + 174, + 57, + 158, + 78, + 236, + 114, + 186 + ], + "nonce": [ + 90, + 219, + 150, + 9, + 219, + 174, + 181, + 140, + 189, + 110, + 114, + 117 + ], + "aad": [ + 136, + 49, + 157, + 110, + 29, + 63, + 250, + 95, + 152, + 113, + 153, + 22, + 108, + 138, + 155, + 86, + 194, + 174, + 186, + 90 + ], + "plaintext": [ + 124, + 14, + 136, + 200, + 136, + 153, + 167, + 121, + 34, + 132, + 101, + 7, + 71, + 151, + 205, + 76, + 46, + 20, + 152, + 210, + 89, + 181, + 67, + 144, + 184, + 94, + 62, + 239, + 28, + 2, + 223, + 96, + 231, + 67, + 241, + 184, + 64, + 56, + 44, + 75, + 204, + 175, + 59, + 175, + 180, + 202, + 132, + 41, + 190, + 160, + 99 + ], + "ciphertext": [ + 152, + 244, + 130, + 111, + 5, + 162, + 101, + 230, + 221, + 43, + 232, + 45, + 178, + 65, + 192, + 251, + 187, + 249, + 255, + 177, + 193, + 115, + 170, + 131, + 150, + 75, + 124, + 245, + 57, + 48, + 67, + 115, + 99, + 101, + 37, + 61, + 219, + 197, + 219, + 135, + 120, + 55, + 20, + 149, + 218, + 118, + 210, + 105, + 229, + 219, + 62 + ], + "tag": [ + 41, + 30, + 241, + 152, + 46, + 77, + 239, + 237, + 170, + 34, + 73, + 248, + 152, + 85, + 107, + 71 + ] + }, + { + "key": [ + 236, + 12, + 43, + 161, + 122, + 169, + 92, + 214, + 175, + 255, + 233, + 73, + 218, + 156, + 195, + 168 + ], + "nonce": [ + 41, + 107, + 206, + 91, + 80, + 183, + 214, + 96, + 150, + 214, + 39, + 239 + ], + "aad": [ + 248, + 208, + 15, + 5, + 210, + 43, + 246, + 133, + 153, + 188, + 222, + 177, + 49, + 41, + 42, + 214, + 226, + 223, + 93, + 20 + ], + "plaintext": [ + 184, + 91, + 55, + 83, + 83, + 91, + 130, + 92, + 190, + 95, + 99, + 44, + 11, + 132, + 60, + 116, + 19, + 81, + 241, + 138, + 164, + 132, + 40, + 26, + 235, + 236, + 47, + 69, + 187, + 158, + 234, + 45, + 121, + 217, + 135, + 183, + 100, + 185, + 97, + 31, + 108, + 15, + 134, + 65, + 132, + 61, + 93, + 88, + 243, + 162, + 66 + ], + "ciphertext": [ + 167, + 68, + 61, + 49, + 194, + 107, + 223, + 42, + 28, + 148, + 94, + 41, + 238, + 75, + 211, + 68, + 169, + 156, + 250, + 243, + 170, + 113, + 248, + 179, + 241, + 145, + 248, + 60, + 42, + 223, + 199, + 160, + 113, + 98, + 153, + 85, + 6, + 253, + 230, + 48, + 159, + 252, + 25, + 231, + 22, + 237, + 223, + 26, + 130, + 140, + 90 + ], + "tag": [ + 137, + 1, + 71, + 151, + 25, + 70, + 182, + 39, + 196, + 0, + 22, + 218, + 30, + 207, + 62, + 119 + ] + }, + { + "key": [ + 212, + 65, + 40, + 9, + 5, + 163, + 59, + 207, + 2, + 172, + 22, + 248, + 202, + 190, + 151, + 204 + ], + "nonce": [ + 83, + 41, + 79, + 139, + 68, + 12, + 130, + 219, + 217, + 189, + 117, + 67 + ], + "aad": [ + 174, + 205, + 73, + 203, + 136, + 144, + 128, + 109, + 71, + 169, + 80, + 200, + 233, + 42, + 178, + 148, + 243, + 37, + 150, + 29 + ], + "plaintext": [ + 92, + 212, + 43, + 21, + 13, + 183, + 208, + 189, + 101, + 86, + 227, + 126, + 56, + 109, + 250, + 250, + 250, + 190, + 42, + 239, + 237, + 40, + 35, + 190, + 147, + 47, + 157, + 175, + 18, + 52, + 170, + 4, + 2, + 190, + 173, + 72, + 94, + 189, + 163, + 160, + 166, + 227, + 146, + 213, + 176, + 230, + 3, + 174, + 45, + 252, + 165 + ], + "ciphertext": [ + 58, + 231, + 65, + 147, + 201, + 78, + 187, + 150, + 251, + 177, + 188, + 94, + 205, + 24, + 11, + 44, + 14, + 250, + 30, + 244, + 169, + 236, + 182, + 149, + 150, + 49, + 248, + 85, + 79, + 14, + 178, + 55, + 137, + 52, + 118, + 204, + 13, + 79, + 181, + 95, + 161, + 136, + 9, + 137, + 193, + 97, + 109, + 211, + 43, + 150, + 79 + ], + "tag": [ + 14, + 174, + 1, + 168, + 71, + 58, + 143, + 96, + 60, + 106, + 230, + 182, + 55, + 228, + 174, + 186 + ] + }, + { + "key": [ + 79, + 102, + 242, + 24, + 23, + 209, + 134, + 92, + 47, + 182, + 45, + 77, + 227, + 68, + 224, + 133 + ], + "nonce": [ + 76, + 120, + 10, + 39, + 7, + 245, + 103, + 71, + 178, + 74, + 74, + 160 + ], + "aad": [ + 76, + 14, + 194, + 83, + 21, + 66, + 188, + 128, + 27, + 61, + 223, + 89, + 60, + 46, + 27, + 164, + 175, + 235, + 96, + 62 + ], + "plaintext": [ + 4, + 234, + 222, + 45, + 104, + 220, + 60, + 93, + 131, + 242, + 211, + 241, + 196, + 66, + 64, + 191, + 134, + 18, + 124, + 159, + 107, + 57, + 102, + 8, + 94, + 244, + 30, + 245, + 1, + 7, + 208, + 66, + 177, + 139, + 190, + 128, + 189, + 67, + 205, + 209, + 88, + 95, + 197, + 169, + 157, + 248, + 39, + 27, + 155, + 135, + 103 + ], + "ciphertext": [ + 220, + 223, + 141, + 43, + 13, + 56, + 128, + 114, + 206, + 39, + 58, + 211, + 80, + 45, + 234, + 81, + 34, + 186, + 192, + 2, + 10, + 122, + 227, + 185, + 119, + 5, + 211, + 162, + 187, + 73, + 165, + 203, + 79, + 149, + 230, + 203, + 215, + 65, + 131, + 117, + 140, + 46, + 171, + 201, + 234, + 56, + 21, + 92, + 126, + 246, + 71 + ], + "tag": [ + 37, + 88, + 197, + 156, + 199, + 215, + 26, + 47, + 206, + 221, + 19, + 241, + 198, + 101, + 154, + 99 + ] + }, + { + "key": [ + 99, + 130, + 118, + 7, + 15, + 112, + 164, + 141, + 253, + 211, + 7, + 73, + 5, + 244, + 221, + 139 + ], + "nonce": [ + 8, + 170, + 5, + 238, + 233, + 190, + 57, + 242, + 143, + 97, + 41, + 156 + ], + "aad": [ + 126, + 62, + 246, + 249, + 217, + 211, + 58, + 107, + 197, + 144, + 75, + 19, + 23, + 210, + 53, + 206, + 26, + 153, + 255, + 179 + ], + "plaintext": [ + 188, + 166, + 59, + 31, + 212, + 128, + 183, + 198, + 130, + 249, + 146, + 179, + 172, + 64, + 113, + 44, + 212, + 18, + 229, + 189, + 81, + 65, + 18, + 99, + 17, + 234, + 60, + 92, + 217, + 31, + 248, + 215, + 91, + 122, + 215, + 190, + 10, + 199, + 246, + 29, + 65, + 41, + 46, + 103, + 49, + 119, + 229, + 94, + 20, + 139, + 140 + ], + "ciphertext": [ + 250, + 177, + 106, + 175, + 140, + 206, + 38, + 88, + 107, + 80, + 231, + 148, + 232, + 137, + 131, + 158, + 14, + 219, + 99, + 241, + 79, + 146, + 127, + 53, + 53, + 105, + 202, + 193, + 105, + 70, + 4, + 222, + 89, + 61, + 114, + 197, + 41, + 119, + 191, + 127, + 226, + 182, + 252, + 236, + 178, + 216, + 145, + 141, + 13, + 232, + 233 + ], + "tag": [ + 189, + 151, + 170, + 205, + 176, + 43, + 128, + 160, + 20, + 135, + 214, + 144, + 181, + 233, + 5, + 187 + ] + }, + { + "key": [ + 220, + 127, + 169, + 52, + 139, + 127, + 225, + 179, + 190, + 250, + 90, + 9, + 178, + 220, + 15, + 122 + ], + "nonce": [ + 81, + 226, + 8, + 207, + 169, + 185, + 217, + 144, + 1, + 63, + 80, + 243 + ], + "aad": [ + 183, + 33, + 155, + 91, + 24, + 1, + 69, + 125, + 113, + 207, + 190, + 52, + 33, + 72, + 132, + 150, + 34, + 89, + 44, + 64 + ], + "plaintext": [ + 11, + 101, + 128, + 11, + 77, + 194, + 170, + 175, + 188, + 131, + 127, + 158, + 206, + 122, + 145, + 17, + 243, + 186, + 3, + 9, + 25, + 107, + 171, + 170, + 107, + 99, + 239, + 15, + 237, + 171, + 119, + 158, + 13, + 53, + 41, + 51, + 83, + 101, + 32, + 228, + 255, + 28, + 127, + 7, + 149, + 5, + 234, + 216, + 130, + 173, + 240 + ], + "ciphertext": [ + 44, + 170, + 229, + 146, + 60, + 173, + 121, + 128, + 45, + 104, + 33, + 114, + 245, + 129, + 145, + 52, + 146, + 64, + 162, + 78, + 37, + 137, + 20, + 97, + 174, + 101, + 57, + 75, + 149, + 65, + 59, + 52, + 224, + 63, + 53, + 81, + 186, + 241, + 160, + 85, + 210, + 42, + 83, + 168, + 163, + 143, + 142, + 247, + 143, + 109, + 64 + ], + "tag": [ + 16, + 118, + 154, + 232, + 84, + 248, + 41, + 140, + 217, + 76, + 40, + 195, + 226, + 142, + 148, + 227 + ] + }, + { + "key": [ + 234, + 241, + 101, + 158, + 8, + 208, + 242, + 42, + 112, + 66, + 53, + 138, + 176, + 238, + 15, + 13 + ], + "nonce": [ + 214, + 145, + 27, + 104, + 133, + 96, + 56, + 239, + 157, + 236, + 18, + 21 + ], + "aad": [ + 67, + 58, + 230, + 56, + 33, + 76, + 72, + 32, + 127, + 233, + 205, + 199, + 110, + 249, + 158, + 40, + 145, + 61, + 106, + 140 + ], + "plaintext": [ + 14, + 113, + 179, + 118, + 95, + 23, + 224, + 22, + 195, + 2, + 75, + 226, + 61, + 10, + 246, + 207, + 80, + 206, + 152, + 216, + 105, + 67, + 179, + 140, + 187, + 232, + 243, + 220, + 181, + 64, + 221, + 166, + 75, + 119, + 191, + 115, + 199, + 205, + 161, + 8, + 225, + 165, + 196, + 189, + 181, + 144, + 167, + 247, + 71, + 236, + 253 + ], + "ciphertext": [ + 191, + 74, + 255, + 101, + 251, + 125, + 240, + 133, + 137, + 98, + 71, + 75, + 238, + 159, + 191, + 149, + 176, + 240, + 102, + 55, + 199, + 215, + 43, + 177, + 203, + 171, + 228, + 102, + 98, + 244, + 85, + 211, + 129, + 54, + 101, + 71, + 123, + 75, + 173, + 251, + 32, + 106, + 77, + 143, + 1, + 52, + 97, + 25, + 229, + 89, + 236 + ], + "tag": [ + 134, + 111, + 32, + 75, + 4, + 163, + 9, + 212, + 94, + 101, + 234, + 137, + 10, + 23, + 237, + 13 + ] + }, + { + "key": [ + 56, + 38, + 151, + 252, + 44, + 162, + 32, + 165, + 214, + 167, + 0, + 247, + 250, + 219, + 170, + 229 + ], + "nonce": [ + 63, + 233, + 212, + 0, + 209, + 13, + 195, + 53, + 69, + 214, + 204, + 92 + ], + "aad": [ + 163, + 205, + 75, + 2, + 22, + 55, + 137, + 24, + 164, + 98, + 82, + 202, + 22, + 242, + 172, + 151, + 117, + 233, + 147, + 249 + ], + "plaintext": [ + 125, + 24, + 122, + 31, + 212, + 213, + 24, + 25, + 124, + 30, + 132, + 61, + 97, + 55, + 151, + 212, + 169, + 250, + 157, + 166, + 254, + 159, + 119, + 59, + 148, + 125, + 204, + 0, + 35, + 196, + 62, + 145, + 125, + 245, + 117, + 186, + 173, + 234, + 144, + 35, + 125, + 149, + 248, + 140, + 84, + 105, + 46, + 248, + 190, + 103, + 46 + ], + "ciphertext": [ + 142, + 100, + 11, + 135, + 157, + 71, + 61, + 124, + 230, + 104, + 145, + 117, + 128, + 139, + 146, + 91, + 107, + 161, + 23, + 122, + 216, + 176, + 197, + 50, + 8, + 225, + 183, + 198, + 48, + 56, + 68, + 245, + 44, + 140, + 174, + 87, + 145, + 208, + 174, + 206, + 234, + 2, + 141, + 172, + 16, + 127, + 173, + 94, + 128, + 134, + 108 + ], + "tag": [ + 56, + 73, + 228, + 254, + 252, + 236, + 177, + 8, + 248, + 61, + 220, + 3, + 154, + 33, + 221, + 145 + ] + }, + { + "key": [ + 24, + 111, + 106, + 115, + 172, + 130, + 227, + 63, + 105, + 197, + 177, + 88, + 199, + 238, + 28, + 190 + ], + "nonce": [ + 186, + 212, + 27, + 254, + 139, + 103, + 21, + 17, + 49, + 232, + 91, + 43 + ], + "aad": [ + 218, + 180, + 150, + 174, + 20, + 18, + 90, + 242, + 254, + 244, + 126, + 227, + 178, + 38, + 166, + 201, + 46, + 153, + 185, + 224 + ], + "plaintext": [ + 204, + 77, + 157, + 194, + 223, + 134, + 22, + 83, + 67, + 170, + 218, + 96, + 203, + 92, + 29, + 159, + 153, + 19, + 49, + 213, + 48, + 216, + 96, + 219, + 249, + 22, + 105, + 7, + 211, + 148, + 114, + 27, + 42, + 34, + 181, + 58, + 107, + 7, + 12, + 92, + 179, + 43, + 163, + 120, + 143, + 245, + 91, + 198, + 160, + 213, + 243 + ], + "ciphertext": [ + 65, + 161, + 124, + 59, + 24, + 230, + 125, + 132, + 191, + 171, + 52, + 75, + 255, + 20, + 41, + 168, + 124, + 48, + 118, + 135, + 158, + 164, + 35, + 131, + 209, + 230, + 34, + 231, + 16, + 166, + 6, + 18, + 238, + 207, + 47, + 174, + 138, + 86, + 169, + 90, + 8, + 201, + 88, + 165, + 47, + 135, + 62, + 203, + 48, + 55, + 133 + ], + "tag": [ + 51, + 80, + 21, + 225, + 77, + 44, + 216, + 235, + 152, + 19, + 121, + 156, + 92, + 112, + 58, + 137 + ] + }, + { + "key": [ + 20, + 186, + 57, + 1, + 218, + 249, + 219, + 64, + 213, + 223, + 189, + 130, + 138, + 54, + 26, + 184 + ], + "nonce": [ + 175, + 55, + 25, + 39, + 7, + 163, + 128, + 75, + 235, + 87, + 200, + 54 + ], + "aad": [ + 26, + 196, + 163, + 142, + 131, + 100, + 144, + 4, + 114, + 125, + 43, + 43, + 113, + 7, + 82, + 100, + 207, + 202, + 222, + 9 + ], + "plaintext": [ + 133, + 240, + 22, + 248, + 60, + 235, + 167, + 106, + 6, + 142, + 93, + 239, + 62, + 213, + 235, + 172, + 133, + 226, + 3, + 198, + 158, + 50, + 103, + 101, + 80, + 198, + 237, + 134, + 78, + 223, + 210, + 204, + 178, + 200, + 218, + 65, + 90, + 66, + 204, + 110, + 173, + 121, + 30, + 134, + 146, + 150, + 9, + 30, + 254, + 124, + 160 + ], + "ciphertext": [ + 42, + 104, + 46, + 85, + 121, + 215, + 248, + 1, + 253, + 189, + 221, + 178, + 181, + 248, + 86, + 76, + 158, + 145, + 195, + 156, + 222, + 71, + 196, + 138, + 193, + 223, + 253, + 247, + 239, + 22, + 116, + 237, + 147, + 126, + 119, + 33, + 86, + 145, + 17, + 10, + 183, + 48, + 175, + 151, + 52, + 159, + 132, + 18, + 142, + 237, + 86 + ], + "tag": [ + 177, + 181, + 2, + 152, + 244, + 139, + 150, + 230, + 121, + 195, + 215, + 31, + 61, + 23, + 214, + 35 + ] + }, + { + "key": [ + 192, + 85, + 43, + 47, + 84, + 244, + 232, + 41, + 33, + 25, + 219, + 246, + 18, + 133, + 254, + 205 + ], + "nonce": [ + 181, + 165, + 128, + 236, + 35, + 117, + 54, + 144, + 214, + 199, + 57, + 47 + ], + "aad": [ + 70, + 202, + 216, + 63, + 190, + 164, + 196, + 123, + 147, + 116, + 186, + 203, + 7, + 36, + 114, + 237, + 206, + 206, + 154, + 207 + ], + "plaintext": [ + 136, + 192, + 79, + 52, + 33, + 222, + 65, + 95, + 158, + 233, + 180, + 126, + 3, + 54, + 102, + 192, + 209, + 130, + 208, + 79, + 56, + 230, + 250, + 255, + 95, + 238, + 94, + 200, + 157, + 27, + 211, + 145, + 7, + 158, + 144, + 251, + 34, + 197, + 55, + 239, + 228, + 86, + 23, + 24, + 88, + 142, + 171, + 49, + 60, + 253, + 92 + ], + "ciphertext": [ + 44, + 168, + 58, + 74, + 99, + 222, + 64, + 74, + 210, + 48, + 106, + 73, + 24, + 66, + 15, + 227, + 16, + 92, + 247, + 249, + 165, + 45, + 22, + 170, + 97, + 14, + 59, + 105, + 160, + 254, + 210, + 70, + 218, + 65, + 118, + 140, + 128, + 28, + 25, + 215, + 80, + 44, + 204, + 205, + 91, + 160, + 161, + 188, + 11, + 80, + 246 + ], + "tag": [ + 140, + 3, + 48, + 78, + 138, + 116, + 221, + 82, + 212, + 227, + 186, + 236, + 137, + 205, + 57, + 125 + ] + }, + { + "key": [ + 198, + 239, + 190, + 237, + 202, + 151, + 156, + 178, + 196, + 250, + 93, + 100, + 84, + 167, + 125, + 193 + ], + "nonce": [ + 78, + 87, + 223, + 73, + 136, + 217, + 61, + 19, + 220, + 81, + 36, + 135 + ], + "aad": [ + 158, + 101, + 208, + 84, + 39, + 17, + 254, + 87, + 171, + 253, + 162, + 117, + 135, + 239, + 65, + 97, + 235, + 63, + 227, + 46 + ], + "plaintext": [ + 165, + 32, + 119, + 73, + 27, + 32, + 172, + 101, + 239, + 248, + 155, + 208, + 189, + 182, + 21, + 12, + 167, + 85, + 207, + 70, + 156, + 66, + 235, + 188, + 92, + 149, + 187, + 207, + 58, + 186, + 145, + 169, + 0, + 43, + 243, + 134, + 252, + 154, + 18, + 111, + 174, + 115, + 219, + 178, + 218, + 167, + 206, + 183, + 157, + 11, + 95 + ], + "ciphertext": [ + 77, + 216, + 3, + 207, + 108, + 153, + 210, + 206, + 62, + 232, + 161, + 153, + 111, + 82, + 131, + 126, + 82, + 195, + 187, + 56, + 108, + 252, + 39, + 146, + 49, + 142, + 27, + 166, + 76, + 53, + 182, + 56, + 201, + 80, + 139, + 46, + 33, + 209, + 218, + 110, + 99, + 94, + 89, + 227, + 124, + 2, + 192, + 176, + 162, + 82, + 157 + ], + "tag": [ + 175, + 132, + 124, + 228, + 25, + 250, + 84, + 4, + 90, + 139, + 243, + 16, + 98, + 246, + 211, + 73 + ] + }, + { + "key": [ + 61, + 104, + 64, + 29, + 124, + 95, + 92, + 10, + 37, + 41, + 237, + 224, + 7, + 36, + 190, + 20 + ], + "nonce": [ + 63, + 62, + 175, + 118, + 231, + 134, + 232, + 175, + 84, + 186, + 165, + 111 + ], + "aad": [ + 106, + 110, + 62, + 168, + 21, + 224, + 28, + 218, + 120, + 167, + 107, + 15, + 184, + 189, + 175, + 184, + 162, + 90, + 107, + 126 + ], + "plaintext": [ + 139, + 254, + 174, + 29, + 173, + 252, + 85, + 186, + 202, + 25, + 26, + 106, + 63, + 84, + 171, + 114, + 24, + 98, + 197, + 28, + 230, + 132, + 228, + 174, + 166, + 233, + 163, + 226, + 243, + 210, + 170, + 193, + 74, + 241, + 203, + 2, + 82, + 242, + 154, + 76, + 140, + 9, + 132, + 206, + 134, + 122, + 206, + 188, + 117, + 150, + 199 + ], + "ciphertext": [ + 138, + 98, + 184, + 26, + 105, + 230, + 225, + 4, + 220, + 7, + 92, + 195, + 39, + 48, + 255, + 203, + 65, + 155, + 159, + 65, + 113, + 30, + 6, + 215, + 194, + 217, + 232, + 145, + 168, + 141, + 198, + 232, + 136, + 23, + 207, + 91, + 194, + 184, + 126, + 149, + 196, + 103, + 141, + 175, + 12, + 164, + 184, + 241, + 224, + 57, + 39 + ], + "tag": [ + 158, + 235, + 188, + 238, + 70, + 86, + 95, + 212, + 195, + 75, + 143, + 71, + 188, + 217, + 75, + 49 + ] + }, + { + "key": [ + 6, + 87, + 187, + 89, + 108, + 194, + 142, + 175, + 213, + 28, + 192, + 154, + 62, + 110, + 193, + 246 + ], + "nonce": [ + 142, + 17, + 160, + 98, + 95, + 186, + 81, + 105, + 134, + 20, + 248, + 249 + ], + "aad": [ + 207, + 115, + 113, + 84, + 116, + 228, + 157, + 113, + 244, + 245, + 173, + 8, + 226, + 9, + 255, + 151, + 116, + 174, + 150, + 57 + ], + "plaintext": [ + 67, + 95, + 22, + 245, + 106, + 167, + 23, + 52, + 220, + 101, + 113, + 226, + 113, + 66, + 7, + 247, + 255, + 133, + 199, + 238, + 170, + 24, + 121, + 144, + 31, + 47, + 250, + 0, + 234, + 69, + 3, + 141, + 181, + 67, + 41, + 240, + 162, + 231, + 138, + 197, + 138, + 93, + 118, + 49, + 71, + 136, + 216, + 53, + 23, + 119, + 250 + ], + "ciphertext": [ + 216, + 118, + 51, + 159, + 13, + 179, + 191, + 240, + 34, + 203, + 69, + 4, + 254, + 10, + 138, + 226, + 96, + 64, + 16, + 47, + 87, + 94, + 205, + 78, + 69, + 131, + 176, + 73, + 89, + 151, + 98, + 84, + 208, + 115, + 132, + 20, + 27, + 165, + 116, + 141, + 53, + 121, + 129, + 94, + 59, + 94, + 29, + 30, + 143, + 221, + 170 + ], + "tag": [ + 126, + 111, + 112, + 150, + 228, + 37, + 145, + 31, + 231, + 57, + 172, + 144, + 204, + 160, + 95, + 218 + ] + }, + { + "key": [ + 178, + 198, + 69, + 224, + 242, + 221, + 13, + 33, + 233, + 81, + 19, + 100, + 249, + 53, + 89, + 25 + ], + "nonce": [ + 145, + 246, + 240, + 137, + 245, + 232, + 40, + 214, + 253, + 241, + 37, + 16 + ], + "aad": [ + 230, + 120, + 31, + 248, + 144, + 50, + 223, + 94, + 83, + 152, + 16, + 143, + 29, + 86, + 157, + 127, + 131, + 39, + 178, + 92 + ], + "plaintext": [ + 60, + 1, + 21, + 158, + 71, + 135, + 167, + 74, + 112, + 123, + 78, + 173, + 59, + 225, + 38, + 184, + 25, + 131, + 18, + 150, + 130, + 31, + 26, + 221, + 57, + 71, + 98, + 172, + 151, + 89, + 156, + 200, + 16, + 189, + 151, + 32, + 93, + 7, + 67, + 84, + 142, + 113, + 80, + 191, + 190, + 109, + 156, + 27, + 165, + 213, + 129 + ], + "ciphertext": [ + 26, + 6, + 222, + 193, + 142, + 180, + 201, + 179, + 97, + 241, + 242, + 236, + 99, + 145, + 218, + 242, + 117, + 241, + 93, + 151, + 167, + 241, + 167, + 63, + 190, + 29, + 20, + 75, + 193, + 225, + 1, + 130, + 0, + 247, + 37, + 213, + 36, + 0, + 198, + 147, + 164, + 56, + 237, + 181, + 149, + 253, + 69, + 88, + 196, + 34, + 122 + ], + "tag": [ + 69, + 23, + 131, + 135, + 79, + 157, + 146, + 83, + 40, + 32, + 139, + 196, + 197, + 110, + 237, + 51 + ] + }, + { + "key": [ + 60, + 80, + 98, + 40, + 104, + 244, + 80, + 170, + 9, + 40, + 153, + 12, + 21, + 225, + 235, + 54 + ], + "nonce": [ + 129, + 29, + 82, + 144, + 118, + 141, + 87, + 231, + 216, + 123, + 182, + 199 + ], + "aad": [ + 218, + 226, + 199, + 224, + 163, + 211, + 253, + 43, + 192, + 78, + 202, + 25, + 177, + 81, + 120, + 160, + 3, + 181, + 207, + 132, + 137, + 12, + 40, + 194, + 166, + 21, + 242, + 15, + 138, + 219, + 66, + 127, + 112, + 105, + 140, + 18, + 178, + 239, + 135, + 120, + 12, + 17, + 147, + 251, + 184, + 205, + 22, + 116 + ], + "plaintext": [ + 237, + 208, + 168, + 248, + 40, + 51, + 233, + 25, + 116, + 15, + 226, + 191, + 158, + 222, + 207, + 74, + 200, + 108, + 114, + 220, + 137, + 73, + 12, + 239, + 123, + 105, + 131, + 170, + 175, + 153, + 252, + 133, + 108, + 92, + 200, + 125, + 99, + 249, + 138, + 124, + 134, + 27, + 243, + 39, + 31, + 234, + 109, + 168, + 106, + 21, + 171 + ], + "ciphertext": [ + 165, + 20, + 37, + 176, + 96, + 141, + 59, + 75, + 70, + 212, + 236, + 5, + 202, + 29, + 218, + 240, + 43, + 221, + 32, + 137, + 174, + 5, + 84, + 236, + 251, + 42, + 28, + 132, + 198, + 61, + 130, + 220, + 113, + 221, + 185, + 171, + 27, + 31, + 11, + 73, + 222, + 42, + 210, + 124, + 43, + 81, + 115, + 231, + 0, + 10, + 166 + ], + "tag": [ + 189, + 155, + 94, + 252, + 164, + 128, + 8, + 205, + 151, + 58, + 79, + 125, + 44, + 114, + 56, + 68 + ] + }, + { + "key": [ + 167, + 38, + 140, + 126, + 247, + 187, + 194, + 190, + 74, + 63, + 252, + 40, + 32, + 25, + 251, + 166 + ], + "nonce": [ + 223, + 44, + 91, + 208, + 63, + 44, + 196, + 90, + 7, + 23, + 49, + 68 + ], + "aad": [ + 68, + 91, + 78, + 198, + 197, + 5, + 241, + 50, + 211, + 176, + 18, + 223, + 98, + 79, + 232, + 246, + 233, + 205, + 160, + 216, + 236, + 94, + 30, + 247, + 205, + 232, + 184, + 146, + 89, + 225, + 103, + 214, + 140, + 31, + 180, + 220, + 74, + 120, + 229, + 197, + 147, + 119, + 243, + 46, + 245, + 206, + 164, + 185 + ], + "plaintext": [ + 248, + 139, + 234, + 233, + 49, + 166, + 142, + 216, + 19, + 163, + 91, + 239, + 84, + 189, + 153, + 153, + 253, + 35, + 206, + 74, + 29, + 37, + 142, + 52, + 250, + 193, + 132, + 186, + 121, + 145, + 50, + 164, + 8, + 189, + 228, + 206, + 210, + 55, + 72, + 219, + 91, + 53, + 234, + 150, + 146, + 244, + 225, + 86, + 29, + 76, + 220 + ], + "ciphertext": [ + 234, + 83, + 226, + 100, + 225, + 176, + 246, + 126, + 227, + 124, + 129, + 35, + 77, + 59, + 156, + 37, + 58, + 177, + 169, + 74, + 74, + 209, + 119, + 121, + 239, + 203, + 238, + 240, + 82, + 97, + 41, + 176, + 253, + 34, + 75, + 88, + 132, + 235, + 139, + 56, + 227, + 92, + 224, + 189, + 218, + 34, + 46, + 48, + 245, + 118, + 243 + ], + "tag": [ + 56, + 181, + 239, + 141, + 102, + 15, + 133, + 109, + 73, + 93, + 181, + 15, + 112, + 43, + 180, + 98 + ] + }, + { + "key": [ + 24, + 61, + 198, + 188, + 154, + 73, + 115, + 4, + 1, + 30, + 90, + 164, + 29, + 197, + 117, + 180 + ], + "nonce": [ + 15, + 78, + 41, + 97, + 216, + 172, + 79, + 129, + 245, + 89, + 222, + 124 + ], + "aad": [ + 138, + 222, + 54, + 192, + 214, + 143, + 164, + 49, + 131, + 139, + 235, + 159, + 29, + 106, + 66, + 35, + 101, + 2, + 75, + 213, + 1, + 153, + 121, + 250, + 155, + 9, + 183, + 196, + 75, + 120, + 94, + 5, + 29, + 222, + 213, + 201, + 226, + 31, + 52, + 44, + 243, + 118, + 231, + 44, + 218, + 233, + 82, + 7 + ], + "plaintext": [ + 170, + 173, + 56, + 184, + 71, + 199, + 166, + 252, + 232, + 1, + 255, + 75, + 166, + 38, + 57, + 89, + 44, + 72, + 115, + 130, + 231, + 227, + 171, + 15, + 41, + 208, + 221, + 228, + 50, + 243, + 16, + 40, + 192, + 177, + 76, + 103, + 193, + 92, + 195, + 102, + 76, + 102, + 12, + 25, + 123, + 71, + 146, + 67, + 57, + 36, + 212 + ], + "ciphertext": [ + 56, + 224, + 157, + 118, + 18, + 165, + 54, + 168, + 13, + 46, + 50, + 164, + 107, + 14, + 30, + 74, + 177, + 225, + 2, + 46, + 133, + 68, + 97, + 170, + 126, + 105, + 93, + 122, + 164, + 160, + 3, + 227, + 121, + 192, + 226, + 112, + 250, + 206, + 41, + 225, + 157, + 116, + 212, + 10, + 96, + 251, + 46, + 140, + 114, + 106, + 202 + ], + "tag": [ + 64, + 4, + 233, + 118, + 63, + 74, + 125, + 15, + 203, + 11, + 165, + 124, + 118, + 17, + 242, + 129 + ] + }, + { + "key": [ + 4, + 125, + 203, + 136, + 193, + 107, + 208, + 211, + 45, + 154, + 98, + 114, + 176, + 121, + 227, + 121 + ], + "nonce": [ + 209, + 116, + 237, + 141, + 96, + 192, + 213, + 200, + 20, + 218, + 212, + 246 + ], + "aad": [ + 198, + 86, + 112, + 34, + 189, + 181, + 242, + 243, + 161, + 227, + 215, + 142, + 2, + 2, + 165, + 246, + 180, + 87, + 192, + 235, + 244, + 106, + 75, + 6, + 32, + 175, + 162, + 181, + 186, + 112, + 111, + 26, + 55, + 249, + 50, + 5, + 138, + 253, + 184, + 207, + 78, + 185, + 163, + 129, + 94, + 202, + 212, + 69 + ], + "plaintext": [ + 249, + 87, + 16, + 79, + 31, + 216, + 126, + 158, + 29, + 109, + 53, + 23, + 26, + 28, + 190, + 143, + 178, + 44, + 180, + 234, + 122, + 186, + 49, + 231, + 99, + 231, + 124, + 111, + 41, + 29, + 184, + 28, + 99, + 201, + 16, + 207, + 155, + 141, + 55, + 191, + 147, + 250, + 40, + 253, + 78, + 40, + 8, + 72, + 11, + 88, + 54 + ], + "ciphertext": [ + 183, + 248, + 60, + 183, + 126, + 249, + 56, + 149, + 166, + 114, + 29, + 250, + 253, + 232, + 147, + 0, + 144, + 210, + 169, + 243, + 154, + 29, + 96, + 91, + 187, + 141, + 127, + 224, + 240, + 250, + 131, + 143, + 198, + 209, + 240, + 229, + 229, + 50, + 89, + 45, + 12, + 104, + 130, + 49, + 226, + 65, + 57, + 230, + 53, + 181, + 2 + ], + "tag": [ + 69, + 35, + 104, + 212, + 47, + 138, + 18, + 17, + 180, + 160, + 24, + 173, + 26, + 207, + 131, + 125 + ] + }, + { + "key": [ + 114, + 134, + 254, + 152, + 172, + 12, + 3, + 37, + 47, + 58, + 183, + 234, + 187, + 137, + 136, + 235 + ], + "nonce": [ + 227, + 46, + 112, + 140, + 99, + 2, + 206, + 38, + 144, + 43, + 213, + 153 + ], + "aad": [ + 75, + 144, + 3, + 160, + 37, + 158, + 215, + 10, + 235, + 250, + 188, + 144, + 171, + 231, + 80, + 184, + 136, + 233, + 219, + 69, + 61, + 159, + 149, + 121, + 13, + 117, + 45, + 74, + 185, + 242, + 8, + 238, + 71, + 128, + 70, + 171, + 170, + 155, + 43, + 242, + 69, + 100, + 33, + 96, + 113, + 97, + 50, + 151 + ], + "plaintext": [ + 88, + 250, + 208, + 55, + 230, + 239, + 166, + 86, + 48, + 202, + 20, + 105, + 135, + 37, + 83, + 140, + 104, + 108, + 237, + 73, + 124, + 88, + 74, + 250, + 210, + 24, + 250, + 59, + 117, + 59, + 234, + 167, + 167, + 47, + 171, + 156, + 76, + 16, + 138, + 209, + 75, + 245, + 240, + 36, + 97, + 63, + 145, + 161, + 21, + 86, + 121 + ], + "ciphertext": [ + 234, + 208, + 188, + 78, + 89, + 2, + 96, + 5, + 152, + 249, + 202, + 158, + 145, + 207, + 69, + 67, + 66, + 12, + 214, + 78, + 40, + 26, + 113, + 15, + 232, + 144, + 224, + 207, + 254, + 250, + 128, + 61, + 140, + 4, + 99, + 144, + 218, + 111, + 80, + 253, + 68, + 183, + 232, + 120, + 97, + 172, + 64, + 136, + 181, + 38, + 109 + ], + "tag": [ + 151, + 6, + 89, + 213, + 23, + 13, + 101, + 75, + 85, + 202, + 95, + 121, + 169, + 224, + 105, + 87 + ] + }, + { + "key": [ + 13, + 195, + 9, + 13, + 39, + 134, + 239, + 241, + 103, + 178, + 145, + 232, + 149, + 172, + 34, + 97 + ], + "nonce": [ + 106, + 200, + 243, + 168, + 166, + 20, + 72, + 225, + 254, + 192, + 109, + 109 + ], + "aad": [ + 168, + 85, + 136, + 212, + 101, + 177, + 236, + 45, + 147, + 92, + 225, + 186, + 93, + 99, + 151, + 189, + 87, + 5, + 89, + 21, + 50, + 152, + 48, + 177, + 170, + 74, + 147, + 79, + 32, + 128, + 236, + 244, + 138, + 181, + 246, + 38, + 156, + 202, + 174, + 216, + 161, + 15, + 57, + 139, + 230, + 76, + 219, + 139 + ], + "plaintext": [ + 48, + 23, + 38, + 29, + 32, + 0, + 47, + 175, + 218, + 228, + 37, + 45, + 204, + 155, + 18, + 20, + 233, + 169, + 238, + 149, + 149, + 51, + 211, + 74, + 171, + 19, + 98, + 73, + 202, + 78, + 245, + 42, + 178, + 5, + 234, + 105, + 239, + 230, + 253, + 33, + 237, + 60, + 144, + 248, + 147, + 53, + 147, + 252, + 99, + 69, + 76 + ], + "ciphertext": [ + 31, + 215, + 239, + 196, + 26, + 84, + 55, + 64, + 72, + 229, + 210, + 161, + 150, + 187, + 181, + 183, + 132, + 82, + 99, + 157, + 178, + 50, + 196, + 193, + 6, + 250, + 141, + 166, + 177, + 71, + 26, + 193, + 74, + 175, + 35, + 40, + 233, + 89, + 169, + 197, + 95, + 32, + 29, + 114, + 113, + 69, + 17, + 81, + 191, + 180, + 141 + ], + "tag": [ + 190, + 127, + 240, + 50, + 45, + 77, + 66, + 0, + 157, + 173, + 244, + 142, + 90, + 169, + 57, + 213 + ] + }, + { + "key": [ + 209, + 105, + 40, + 40, + 9, + 221, + 174, + 51, + 132, + 161, + 11, + 144, + 139, + 133, + 38, + 195 + ], + "nonce": [ + 201, + 68, + 138, + 144, + 46, + 5, + 248, + 171, + 16, + 173, + 146, + 232 + ], + "aad": [ + 113, + 177, + 239, + 236, + 78, + 80, + 4, + 29, + 4, + 70, + 224, + 59, + 7, + 255, + 223, + 240, + 92, + 98, + 89, + 217, + 10, + 167, + 179, + 49, + 137, + 233, + 83, + 96, + 191, + 235, + 162, + 58, + 254, + 145, + 77, + 15, + 23, + 219, + 107, + 164, + 126, + 161, + 101, + 204, + 6, + 213, + 1, + 231 + ], + "plaintext": [ + 73, + 11, + 70, + 159, + 132, + 147, + 157, + 98, + 224, + 15, + 222, + 245, + 52, + 48, + 35, + 46, + 91, + 14, + 241, + 48, + 213, + 134, + 187, + 250, + 138, + 61, + 59, + 163, + 13, + 145, + 97, + 75, + 100, + 224, + 218, + 9, + 47, + 22, + 184, + 58, + 70, + 201, + 56, + 110, + 190, + 208, + 191, + 158, + 134, + 57, + 80 + ], + "ciphertext": [ + 202, + 105, + 59, + 35, + 80, + 210, + 56, + 8, + 132, + 8, + 112, + 194, + 55, + 31, + 73, + 237, + 164, + 83, + 242, + 225, + 137, + 199, + 11, + 151, + 90, + 242, + 83, + 27, + 158, + 139, + 13, + 140, + 38, + 40, + 41, + 230, + 31, + 137, + 144, + 128, + 72, + 68, + 172, + 148, + 27, + 47, + 228, + 115, + 153, + 168, + 141 + ], + "tag": [ + 139, + 201, + 226, + 90, + 86, + 137, + 135, + 180, + 39, + 207, + 197, + 180, + 46, + 65, + 45, + 122 + ] + }, + { + "key": [ + 147, + 129, + 72, + 57, + 218, + 32, + 181, + 96, + 38, + 138, + 216, + 254, + 37, + 122, + 147, + 114 + ], + "nonce": [ + 241, + 87, + 172, + 74, + 131, + 167, + 183, + 59, + 128, + 133, + 8, + 93 + ], + "aad": [ + 155, + 66, + 46, + 116, + 242, + 16, + 153, + 37, + 38, + 76, + 28, + 13, + 218, + 43, + 104, + 201, + 121, + 175, + 218, + 193, + 16, + 228, + 43, + 129, + 175, + 210, + 197, + 158, + 45, + 243, + 255, + 63, + 147, + 131, + 37, + 82, + 182, + 38, + 179, + 130, + 18, + 18, + 163, + 226, + 12, + 64, + 25, + 73 + ], + "plaintext": [ + 187, + 173, + 146, + 45, + 230, + 222, + 167, + 21, + 55, + 36, + 163, + 51, + 85, + 78, + 26, + 175, + 46, + 55, + 174, + 205, + 24, + 43, + 69, + 136, + 93, + 4, + 243, + 209, + 28, + 55, + 99, + 254, + 89, + 194, + 104, + 40, + 211, + 12, + 157, + 169, + 90, + 219, + 117, + 251, + 213, + 251, + 210, + 230, + 236, + 225, + 44 + ], + "ciphertext": [ + 190, + 6, + 155, + 65, + 77, + 147, + 212, + 246, + 65, + 176, + 83, + 241, + 238, + 122, + 97, + 226, + 59, + 242, + 135, + 166, + 59, + 29, + 6, + 192, + 83, + 147, + 232, + 250, + 165, + 133, + 109, + 34, + 114, + 75, + 252, + 81, + 26, + 48, + 106, + 228, + 186, + 18, + 192, + 160, + 81, + 180, + 121, + 227, + 92, + 34, + 154 + ], + "tag": [ + 83, + 166, + 47, + 148, + 49, + 184, + 230, + 18, + 76, + 155, + 246, + 41, + 143, + 27, + 40, + 128 + ] + }, + { + "key": [ + 50, + 98, + 242, + 68, + 43, + 137, + 163, + 100, + 20, + 86, + 207, + 163, + 212, + 209, + 134, + 252 + ], + "nonce": [ + 208, + 252, + 79, + 143, + 123, + 183, + 74, + 23, + 99, + 134, + 36, + 7 + ], + "aad": [ + 190, + 225, + 200, + 237, + 82, + 191, + 52, + 116, + 49, + 186, + 188, + 202, + 194, + 166, + 66, + 117, + 34, + 64, + 69, + 213, + 193, + 18, + 46, + 184, + 194, + 172, + 61, + 135, + 145, + 165, + 169, + 195, + 122, + 191, + 5, + 12, + 64, + 110, + 190, + 185, + 71, + 66, + 139, + 182, + 13, + 88, + 208, + 98 + ], + "plaintext": [ + 252, + 221, + 124, + 216, + 58, + 54, + 111, + 148, + 40, + 157, + 139, + 71, + 3, + 69, + 252, + 206, + 162, + 175, + 247, + 120, + 237, + 217, + 246, + 12, + 109, + 130, + 115, + 179, + 39, + 122, + 132, + 57, + 101, + 240, + 212, + 255, + 139, + 225, + 230, + 30, + 232, + 44, + 170, + 232, + 117, + 75, + 135, + 231, + 71, + 178, + 213 + ], + "ciphertext": [ + 208, + 229, + 206, + 207, + 50, + 239, + 101, + 3, + 85, + 70, + 207, + 138, + 153, + 220, + 126, + 111, + 67, + 32, + 55, + 111, + 142, + 22, + 165, + 25, + 88, + 220, + 121, + 108, + 155, + 154, + 55, + 160, + 215, + 78, + 123, + 153, + 121, + 160, + 171, + 91, + 136, + 173, + 146, + 152, + 141, + 193, + 132, + 185, + 100, + 161, + 31 + ], + "tag": [ + 55, + 197, + 44, + 212, + 30, + 226, + 213, + 25, + 170, + 131, + 99, + 177, + 134, + 170, + 220, + 196 + ] + }, + { + "key": [ + 252, + 147, + 115, + 72, + 164, + 70, + 138, + 250, + 166, + 41, + 241, + 88, + 220, + 255, + 90, + 110 + ], + "nonce": [ + 120, + 58, + 168, + 129, + 186, + 9, + 56, + 237, + 143, + 232, + 234, + 48 + ], + "aad": [ + 49, + 178, + 137, + 42, + 102, + 156, + 206, + 151, + 76, + 43, + 70, + 125, + 132, + 196, + 81, + 137, + 179, + 53, + 165, + 148, + 61, + 67, + 178, + 241, + 88, + 213, + 193, + 115, + 190, + 79, + 227, + 31, + 129, + 66, + 241, + 182, + 151, + 199, + 114, + 241, + 117, + 166, + 93, + 216, + 122, + 229, + 251, + 82 + ], + "plaintext": [ + 13, + 182, + 40, + 94, + 210, + 49, + 67, + 118, + 45, + 110, + 155, + 112, + 143, + 12, + 132, + 237, + 63, + 72, + 213, + 30, + 139, + 61, + 165, + 73, + 241, + 206, + 19, + 11, + 212, + 52, + 208, + 195, + 130, + 56, + 208, + 226, + 198, + 226, + 183, + 246, + 163, + 94, + 186, + 44, + 216, + 77, + 40, + 120, + 29, + 255, + 25 + ], + "ciphertext": [ + 41, + 214, + 101, + 121, + 31, + 172, + 9, + 167, + 45, + 210, + 23, + 141, + 105, + 222, + 22, + 165, + 234, + 52, + 50, + 191, + 112, + 172, + 250, + 161, + 116, + 236, + 76, + 201, + 61, + 247, + 239, + 255, + 95, + 60, + 5, + 124, + 31, + 250, + 204, + 128, + 235, + 41, + 145, + 177, + 199, + 154, + 181, + 101, + 193, + 249, + 122 + ], + "tag": [ + 17, + 58, + 45, + 208, + 190, + 96, + 221, + 69, + 234, + 79, + 61, + 139, + 144, + 193, + 18, + 44 + ] + }, + { + "key": [ + 169, + 163, + 59, + 113, + 235, + 129, + 208, + 145, + 172, + 29, + 21, + 228, + 138, + 25, + 160, + 103 + ], + "nonce": [ + 187, + 134, + 185, + 153, + 117, + 49, + 66, + 222, + 101, + 115, + 232, + 99 + ], + "aad": [ + 122, + 75, + 168, + 179, + 14, + 238, + 226, + 244, + 87, + 183, + 70, + 153, + 210, + 255, + 119, + 216, + 249, + 145, + 47, + 9, + 117, + 121, + 114, + 191, + 142, + 94, + 142, + 195, + 118, + 132, + 168, + 225, + 82, + 59, + 10, + 254, + 192, + 174, + 181, + 250, + 186, + 189, + 217, + 69, + 251, + 85, + 234, + 196 + ], + "plaintext": [ + 145, + 2, + 70, + 210, + 67, + 87, + 134, + 253, + 200, + 249, + 80, + 160, + 227, + 167, + 157, + 8, + 30, + 161, + 196, + 30, + 235, + 184, + 117, + 222, + 46, + 238, + 157, + 170, + 168, + 37, + 8, + 80, + 246, + 54, + 82, + 44, + 201, + 83, + 65, + 151, + 103, + 173, + 36, + 152, + 43, + 241, + 68, + 39, + 36, + 57, + 113 + ], + "ciphertext": [ + 164, + 203, + 3, + 153, + 86, + 227, + 152, + 132, + 107, + 172, + 52, + 61, + 183, + 43, + 114, + 222, + 212, + 134, + 246, + 79, + 197, + 140, + 139, + 60, + 61, + 143, + 191, + 31, + 145, + 176, + 15, + 76, + 124, + 42, + 86, + 15, + 136, + 247, + 59, + 126, + 218, + 75, + 242, + 188, + 201, + 212, + 247, + 166, + 198, + 47, + 159 + ], + "tag": [ + 221, + 89, + 79, + 52, + 162, + 159, + 160, + 42, + 243, + 172, + 207, + 86, + 125, + 124, + 82, + 6 + ] + }, + { + "key": [ + 124, + 178, + 249, + 123, + 86, + 9, + 231, + 96, + 64, + 113, + 42, + 149, + 191, + 232, + 79, + 173 + ], + "nonce": [ + 28, + 35, + 152, + 234, + 103, + 193, + 36, + 101, + 64, + 196, + 105, + 171 + ], + "aad": [ + 173, + 211, + 232, + 152, + 114, + 224, + 159, + 100, + 216, + 40, + 70, + 61, + 93, + 247, + 81, + 157, + 225, + 169, + 219, + 118, + 57, + 34, + 155, + 103, + 144, + 27, + 210, + 122, + 195, + 195, + 234, + 97, + 172, + 22, + 18, + 6, + 125, + 114, + 3, + 122, + 218, + 221, + 46, + 20, + 71, + 85, + 132, + 168 + ], + "plaintext": [ + 237, + 228, + 181, + 115, + 44, + 143, + 167, + 190, + 188, + 135, + 247, + 45, + 162, + 226, + 67, + 221, + 65, + 115, + 221, + 173, + 112, + 11, + 239, + 101, + 173, + 238, + 170, + 12, + 87, + 3, + 146, + 252, + 71, + 123, + 61, + 43, + 125, + 64, + 75, + 234, + 64, + 7, + 74, + 109, + 88, + 160, + 15, + 36, + 102, + 193, + 188 + ], + "ciphertext": [ + 108, + 109, + 216, + 166, + 145, + 235, + 34, + 41, + 72, + 24, + 230, + 30, + 51, + 175, + 234, + 158, + 73, + 53, + 61, + 27, + 182, + 246, + 69, + 232, + 33, + 215, + 196, + 195, + 31, + 180, + 64, + 221, + 140, + 194, + 101, + 20, + 80, + 167, + 100, + 162, + 32, + 56, + 151, + 134, + 81, + 255, + 211, + 61, + 75, + 225, + 8 + ], + "tag": [ + 234, + 36, + 107, + 181, + 226, + 171, + 50, + 130, + 194, + 121, + 39, + 205, + 152, + 58, + 114, + 151 + ] + }, + { + "key": [ + 64, + 47, + 200, + 121, + 18, + 111, + 241, + 68, + 121, + 42, + 244, + 9, + 117, + 240, + 162, + 76 + ], + "nonce": [ + 189, + 191, + 110, + 129, + 254, + 255, + 90, + 17, + 223, + 23, + 226, + 5 + ], + "aad": [ + 222, + 132, + 67, + 223, + 68, + 217, + 59, + 55, + 52, + 216, + 130, + 11, + 154, + 38, + 1, + 13, + 108, + 224, + 156, + 27, + 185, + 160, + 34, + 96, + 35, + 90, + 64, + 41, + 157, + 56, + 51, + 15, + 103, + 121, + 45, + 15, + 84, + 192, + 192, + 251, + 53, + 239, + 159, + 235, + 203, + 204, + 208, + 43 + ], + "plaintext": [ + 140, + 96, + 220, + 232, + 11, + 10, + 94, + 245, + 120, + 214, + 128, + 209, + 200, + 17, + 150, + 114, + 101, + 204, + 118, + 100, + 199, + 81, + 250, + 244, + 209, + 71, + 45, + 172, + 91, + 150, + 226, + 110, + 59, + 228, + 57, + 177, + 158, + 61, + 168, + 59, + 26, + 25, + 220, + 130, + 186, + 0, + 212, + 53, + 224, + 51, + 66 + ], + "ciphertext": [ + 135, + 83, + 224, + 30, + 229, + 192, + 136, + 188, + 174, + 19, + 9, + 178, + 228, + 38, + 157, + 159, + 177, + 84, + 145, + 131, + 26, + 30, + 23, + 20, + 8, + 8, + 243, + 10, + 238, + 79, + 165, + 40, + 2, + 10, + 127, + 199, + 223, + 134, + 39, + 205, + 169, + 183, + 64, + 28, + 68, + 177, + 90, + 161, + 231, + 198, + 68 + ], + "tag": [ + 15, + 69, + 124, + 146, + 169, + 154, + 193, + 235, + 161, + 182, + 16, + 93, + 109, + 35, + 206, + 83 + ] + }, + { + "key": [ + 202, + 85, + 73, + 97, + 77, + 192, + 50, + 69, + 100, + 0, + 33, + 57, + 253, + 106, + 54, + 14 + ], + "nonce": [ + 138, + 77, + 227, + 27, + 13, + 220, + 109, + 42, + 53, + 112, + 250, + 192 + ], + "aad": [ + 107, + 136, + 112, + 150, + 39, + 194, + 136, + 37, + 86, + 157, + 96, + 119, + 43, + 102, + 66, + 169, + 218, + 219, + 243, + 234, + 153, + 4, + 178, + 144, + 220, + 99, + 42, + 131, + 125, + 87, + 157, + 46, + 129, + 40, + 75, + 244, + 53, + 9, + 35, + 193, + 134, + 62, + 14, + 141, + 88, + 148, + 163, + 75 + ], + "plaintext": [ + 55, + 97, + 12, + 24, + 125, + 40, + 121, + 130, + 233, + 175, + 193, + 90, + 146, + 80, + 174, + 185, + 25, + 51, + 54, + 157, + 237, + 197, + 145, + 14, + 77, + 229, + 132, + 215, + 12, + 39, + 183, + 228, + 224, + 167, + 176, + 40, + 105, + 41, + 145, + 0, + 253, + 142, + 247, + 91, + 198, + 106, + 228, + 190, + 210, + 168, + 83 + ], + "ciphertext": [ + 41, + 80, + 90, + 245, + 18, + 118, + 140, + 137, + 216, + 64, + 84, + 204, + 232, + 248, + 136, + 158, + 155, + 74, + 9, + 80, + 152, + 185, + 206, + 199, + 226, + 106, + 106, + 252, + 247, + 174, + 229, + 19, + 47, + 180, + 60, + 175, + 126, + 220, + 6, + 143, + 182, + 174, + 163, + 87, + 10, + 217, + 49, + 10, + 92, + 51, + 41 + ], + "tag": [ + 208, + 145, + 128, + 51, + 182, + 219, + 95, + 153, + 159, + 38, + 190, + 217, + 77, + 53, + 42, + 246 + ] + }, + { + "key": [ + 166, + 139, + 100, + 38, + 125, + 13, + 27, + 194, + 217, + 75, + 159, + 105, + 31, + 248, + 233, + 228 + ], + "nonce": [ + 162, + 119, + 6, + 189, + 142, + 174, + 139, + 179, + 220, + 149, + 161, + 185 + ], + "aad": [ + 135, + 52, + 250, + 60, + 236, + 181, + 121, + 59, + 43, + 123, + 203, + 79, + 205, + 231, + 128, + 131, + 3, + 194, + 124, + 44, + 0, + 42, + 39, + 224, + 219, + 170, + 55, + 139, + 61, + 244, + 144, + 158, + 55, + 194, + 56, + 162, + 79, + 175, + 73, + 182, + 205, + 19, + 68, + 25, + 148, + 139, + 222, + 198 + ], + "plaintext": [ + 74, + 153, + 171, + 65, + 198, + 4, + 215, + 33, + 0, + 105, + 217, + 34, + 141, + 211, + 34, + 59, + 111, + 125, + 162, + 21, + 221, + 218, + 22, + 207, + 147, + 191, + 102, + 88, + 120, + 76, + 187, + 254, + 8, + 239, + 106, + 1, + 82, + 206, + 243, + 104, + 65, + 93, + 255, + 159, + 141, + 29, + 5, + 234, + 208, + 67, + 249 + ], + "ciphertext": [ + 67, + 170, + 4, + 50, + 161, + 180, + 104, + 190, + 198, + 77, + 228, + 91, + 102, + 181, + 251, + 62, + 139, + 43, + 217, + 39, + 120, + 1, + 239, + 83, + 161, + 205, + 103, + 87, + 191, + 212, + 90, + 171, + 156, + 107, + 35, + 240, + 161, + 244, + 179, + 15, + 163, + 63, + 229, + 47, + 171, + 231, + 187, + 134, + 40, + 25, + 100 + ], + "tag": [ + 253, + 57, + 239, + 46, + 148, + 112, + 122, + 26, + 186, + 87, + 255, + 45, + 231, + 193, + 121, + 39 + ] + }, + { + "key": [ + 44, + 31, + 33, + 207, + 15, + 111, + 179, + 102, + 25, + 67, + 21, + 92, + 62, + 61, + 132, + 146 + ], + "nonce": [ + 35, + 203, + 95, + 243, + 98, + 226, + 36, + 38, + 152, + 77, + 25, + 7 + ], + "aad": [ + 93, + 54, + 36, + 135, + 157, + 53, + 228, + 104, + 73, + 149, + 62, + 69, + 163, + 42, + 98, + 77, + 106, + 108, + 83, + 110, + 217, + 133, + 124, + 97, + 59, + 87, + 43, + 3, + 51, + 231, + 1, + 85, + 122, + 113, + 62, + 63, + 1, + 14, + 205, + 249, + 166, + 189, + 108, + 158, + 62, + 68, + 176, + 101, + 32, + 134, + 69, + 175, + 244, + 170, + 190, + 230, + 17, + 179, + 145, + 82, + 133, + 20, + 23, + 0, + 132, + 204, + 245, + 135, + 23, + 127, + 68, + 136, + 243, + 60, + 251, + 94, + 151, + 158, + 66, + 182, + 225, + 207, + 192, + 166, + 2, + 56, + 152, + 42, + 122, + 236 + ], + "plaintext": [ + 66, + 247, + 88, + 131, + 105, + 134, + 149, + 77, + 180, + 75, + 243, + 124, + 110, + 245, + 228, + 172, + 10, + 218, + 243, + 143, + 39, + 37, + 42, + 27, + 130, + 208, + 46, + 169, + 73, + 200, + 161, + 162, + 219, + 192, + 214, + 139, + 86, + 21, + 186, + 124, + 18, + 32, + 255, + 101, + 16, + 226, + 89, + 240, + 102, + 85, + 216 + ], + "ciphertext": [ + 129, + 130, + 79, + 14, + 13, + 82, + 61, + 179, + 13, + 61, + 163, + 105, + 253, + 192, + 214, + 8, + 148, + 199, + 160, + 162, + 6, + 70, + 221, + 1, + 80, + 115, + 173, + 39, + 50, + 189, + 152, + 155, + 20, + 162, + 34, + 182, + 173, + 87, + 175, + 67, + 225, + 137, + 93, + 249, + 220, + 162, + 165, + 52, + 74, + 98, + 204 + ], + "tag": [ + 87, + 163, + 238, + 40, + 19, + 110, + 148, + 199, + 72, + 56, + 153, + 122, + 233, + 130, + 63, + 58 + ] + }, + { + "key": [ + 217, + 247, + 210, + 65, + 16, + 145, + 249, + 71, + 180, + 214, + 241, + 226, + 209, + 240, + 251, + 46 + ], + "nonce": [ + 225, + 147, + 79, + 93, + 181, + 124, + 201, + 131, + 230, + 177, + 128, + 231 + ], + "aad": [ + 10, + 138, + 24, + 167, + 21, + 14, + 148, + 12, + 61, + 135, + 179, + 142, + 115, + 186, + 238, + 154, + 92, + 4, + 158, + 226, + 23, + 149, + 102, + 62, + 38, + 75, + 105, + 74, + 148, + 152, + 34, + 182, + 57, + 9, + 45, + 14, + 103, + 1, + 94, + 134, + 54, + 53, + 131, + 252, + 240, + 202, + 100, + 90, + 249, + 244, + 51, + 117, + 240, + 95, + 219, + 76, + 232, + 79, + 65, + 29, + 203, + 202, + 115, + 194, + 34, + 13, + 234, + 3, + 162, + 1, + 21, + 210, + 229, + 19, + 152, + 52, + 75, + 22, + 190, + 225, + 237, + 124, + 73, + 155, + 53, + 61, + 108, + 89, + 122, + 248 + ], + "plaintext": [ + 115, + 237, + 4, + 35, + 39, + 247, + 15, + 233, + 197, + 114, + 166, + 21, + 69, + 237, + 168, + 178, + 160, + 198, + 225, + 214, + 194, + 145, + 239, + 25, + 36, + 142, + 151, + 58, + 238, + 108, + 49, + 32, + 18, + 244, + 144, + 194, + 198, + 246, + 22, + 111, + 74, + 89, + 67, + 30, + 24, + 38, + 99, + 252, + 174, + 160, + 90 + ], + "ciphertext": [ + 170, + 173, + 189, + 92, + 146, + 233, + 21, + 28, + 227, + 219, + 114, + 16, + 184, + 113, + 65, + 38, + 183, + 62, + 67, + 67, + 109, + 36, + 38, + 119, + 175, + 165, + 3, + 132, + 242, + 20, + 155, + 131, + 31, + 29, + 87, + 60, + 120, + 145, + 194, + 169, + 31, + 188, + 72, + 219, + 41, + 150, + 126, + 201, + 84, + 43, + 35 + ], + "tag": [ + 33, + 181, + 28, + 168, + 98, + 203, + 99, + 124, + 221, + 3, + 185, + 154, + 15, + 147, + 177, + 52 + ] + }, + { + "key": [ + 184, + 24, + 117, + 42, + 164, + 69, + 33, + 32, + 128, + 140, + 61, + 33, + 29, + 87, + 194, + 36 + ], + "nonce": [ + 214, + 121, + 160, + 190, + 34, + 194, + 218, + 246, + 25, + 177, + 20, + 99 + ], + "aad": [ + 187, + 133, + 59, + 96, + 181, + 253, + 139, + 210, + 74, + 204, + 157, + 185, + 221, + 61, + 228, + 139, + 119, + 93, + 74, + 92, + 178, + 168, + 121, + 193, + 221, + 120, + 189, + 233, + 76, + 175, + 238, + 6, + 219, + 18, + 161, + 87, + 78, + 173, + 226, + 5, + 223, + 211, + 168, + 198, + 246, + 133, + 153, + 225, + 32, + 236, + 115, + 182, + 180, + 85, + 156, + 208, + 61, + 49, + 24, + 178, + 177, + 187, + 227, + 64, + 187, + 21, + 50, + 12, + 107, + 248, + 216, + 161, + 195, + 193, + 36, + 123, + 64, + 35, + 186, + 41, + 73, + 186, + 106, + 90, + 177, + 63, + 45, + 133, + 185, + 59 + ], + "plaintext": [ + 124, + 205, + 236, + 241, + 49, + 48, + 194, + 15, + 103, + 221, + 111, + 71, + 173, + 236, + 51, + 223, + 181, + 43, + 200, + 74, + 119, + 0, + 67, + 27, + 127, + 211, + 152, + 214, + 82, + 161, + 35, + 240, + 134, + 174, + 25, + 115, + 40, + 207, + 174, + 209, + 39, + 169, + 24, + 102, + 201, + 91, + 223, + 219, + 72, + 73, + 206 + ], + "ciphertext": [ + 188, + 26, + 136, + 108, + 158, + 90, + 204, + 195, + 79, + 12, + 35, + 127, + 126, + 217, + 150, + 233, + 64, + 228, + 176, + 236, + 136, + 38, + 56, + 230, + 152, + 102, + 237, + 36, + 216, + 100, + 103, + 245, + 67, + 58, + 238, + 35, + 68, + 141, + 243, + 149, + 101, + 160, + 236, + 255, + 242, + 196, + 14, + 104, + 87, + 247, + 37 + ], + "tag": [ + 95, + 249, + 196, + 73, + 208, + 191, + 168, + 112, + 235, + 239, + 231, + 141, + 81, + 154, + 141, + 18 + ] + }, + { + "key": [ + 82, + 139, + 137, + 72, + 181, + 52, + 213, + 247, + 128, + 174, + 63, + 30, + 35, + 164, + 122, + 37 + ], + "nonce": [ + 254, + 197, + 234, + 240, + 166, + 214, + 245, + 196, + 173, + 236, + 150, + 24 + ], + "aad": [ + 213, + 19, + 77, + 132, + 169, + 105, + 33, + 83, + 122, + 23, + 134, + 156, + 62, + 208, + 140, + 85, + 194, + 158, + 10, + 103, + 163, + 9, + 67, + 203, + 36, + 136, + 73, + 132, + 55, + 148, + 193, + 198, + 254, + 252, + 152, + 101, + 157, + 169, + 176, + 245, + 5, + 189, + 239, + 194, + 228, + 235, + 233, + 82, + 61, + 42, + 22, + 91, + 99, + 181, + 227, + 178, + 186, + 149, + 53, + 130, + 29, + 98, + 170, + 249, + 91, + 156, + 126, + 111, + 241, + 248, + 128, + 122, + 19, + 231, + 155, + 159, + 229, + 137, + 192, + 217, + 254, + 187, + 171, + 249, + 55, + 43, + 1, + 172, + 32, + 81 + ], + "plaintext": [ + 156, + 82, + 128, + 89, + 19, + 17, + 220, + 33, + 45, + 110, + 226, + 173, + 139, + 131, + 222, + 223, + 3, + 185, + 30, + 36, + 77, + 138, + 66, + 105, + 12, + 154, + 88, + 33, + 171, + 151, + 20, + 83, + 200, + 180, + 246, + 62, + 21, + 187, + 138, + 249, + 106, + 235, + 74, + 62, + 53, + 81, + 91, + 101, + 27, + 198, + 141 + ], + "ciphertext": [ + 189, + 240, + 183, + 82, + 22, + 14, + 100, + 182, + 38, + 213, + 197, + 67, + 149, + 69, + 112, + 22, + 158, + 40, + 176, + 51, + 247, + 123, + 110, + 248, + 163, + 123, + 203, + 174, + 42, + 41, + 74, + 158, + 112, + 96, + 195, + 35, + 91, + 41, + 15, + 121, + 198, + 156, + 57, + 166, + 107, + 13, + 94, + 204, + 129, + 208, + 42 + ], + "tag": [ + 249, + 55, + 104, + 201, + 119, + 129, + 173, + 4, + 134, + 242, + 249, + 232, + 33, + 15, + 42, + 34 + ] + }, + { + "key": [ + 130, + 76, + 168, + 94, + 46, + 75, + 42, + 108, + 110, + 106, + 101, + 239, + 134, + 22, + 197, + 123 + ], + "nonce": [ + 210, + 191, + 146, + 231, + 220, + 83, + 103, + 106, + 172, + 78, + 109, + 29 + ], + "aad": [ + 70, + 90, + 253, + 8, + 215, + 38, + 3, + 8, + 216, + 210, + 16, + 37, + 243, + 21, + 112, + 229, + 220, + 214, + 188, + 189, + 101, + 32, + 236, + 182, + 255, + 133, + 222, + 88, + 55, + 141, + 90, + 246, + 234, + 247, + 203, + 47, + 18, + 66, + 192, + 196, + 123, + 117, + 156, + 88, + 219, + 198, + 228, + 180, + 92, + 139, + 153, + 53, + 20, + 241, + 75, + 130, + 237, + 163, + 252, + 182, + 160, + 223, + 32, + 117, + 160, + 171, + 118, + 250, + 12, + 91, + 108, + 179, + 125, + 29, + 40, + 247, + 115, + 218, + 197, + 145, + 121, + 8, + 135, + 210, + 215, + 47, + 3, + 188, + 197, + 174 + ], + "plaintext": [ + 205, + 72, + 40, + 229, + 151, + 125, + 127, + 197, + 187, + 247, + 246, + 209, + 135, + 11, + 246, + 51, + 60, + 32, + 64, + 135, + 99, + 154, + 59, + 73, + 74, + 64, + 55, + 23, + 11, + 115, + 252, + 107, + 50, + 196, + 85, + 93, + 26, + 2, + 168, + 131, + 116, + 65, + 115, + 77, + 104, + 53, + 165, + 75, + 243, + 90, + 68 + ], + "ciphertext": [ + 77, + 160, + 36, + 116, + 239, + 24, + 157, + 232, + 99, + 213, + 51, + 35, + 255, + 103, + 55, + 193, + 46, + 251, + 61, + 96, + 168, + 144, + 168, + 213, + 57, + 145, + 222, + 87, + 255, + 198, + 202, + 253, + 68, + 196, + 41, + 167, + 98, + 162, + 21, + 76, + 90, + 147, + 113, + 32, + 219, + 33, + 97, + 242, + 207, + 46, + 161 + ], + "tag": [ + 148, + 157, + 57, + 154, + 126, + 37, + 103, + 178, + 117, + 198, + 248, + 66, + 222, + 96, + 38, + 5 + ] + }, + { + "key": [ + 79, + 96, + 183, + 83, + 163, + 107, + 75, + 31, + 46, + 77, + 131, + 0, + 221, + 198, + 103, + 165 + ], + "nonce": [ + 53, + 250, + 37, + 81, + 88, + 31, + 133, + 146, + 19, + 75, + 186, + 69 + ], + "aad": [ + 154, + 0, + 107, + 124, + 234, + 39, + 243, + 180, + 163, + 5, + 255, + 176, + 197, + 190, + 199, + 227, + 88, + 44, + 106, + 59, + 224, + 40, + 235, + 244, + 75, + 178, + 73, + 109, + 174, + 31, + 73, + 47, + 118, + 92, + 198, + 108, + 130, + 211, + 162, + 33, + 42, + 189, + 97, + 66, + 82, + 78, + 7, + 39, + 218, + 184, + 174, + 80, + 110, + 109, + 91, + 157, + 211, + 97, + 227, + 163, + 125, + 243, + 190, + 201, + 91, + 20, + 241, + 23, + 78, + 127, + 37, + 198, + 86, + 170, + 187, + 66, + 152, + 27, + 145, + 149, + 7, + 85, + 40, + 28, + 94, + 248, + 245, + 46, + 87, + 191 + ], + "plaintext": [ + 131, + 128, + 124, + 4, + 41, + 0, + 97, + 31, + 80, + 253, + 66, + 85, + 123, + 124, + 246, + 99, + 21, + 135, + 34, + 37, + 20, + 61, + 44, + 223, + 140, + 5, + 204, + 246, + 136, + 255, + 33, + 218, + 143, + 106, + 37, + 86, + 176, + 5, + 18, + 133, + 184, + 231, + 203, + 138, + 238, + 5, + 183, + 40, + 22, + 171, + 213 + ], + "ciphertext": [ + 205, + 34, + 145, + 172, + 24, + 42, + 182, + 208, + 247, + 182, + 185, + 62, + 103, + 171, + 196, + 34, + 138, + 182, + 58, + 76, + 27, + 33, + 76, + 170, + 17, + 105, + 141, + 64, + 210, + 168, + 170, + 16, + 22, + 75, + 72, + 98, + 77, + 57, + 221, + 150, + 127, + 76, + 53, + 238, + 191, + 9, + 172, + 223, + 229, + 159, + 69 + ], + "tag": [ + 178, + 49, + 187, + 78, + 99, + 221, + 169, + 10, + 17, + 112, + 15, + 32, + 77, + 194, + 177, + 117 + ] + }, + { + "key": [ + 7, + 177, + 34, + 166, + 24, + 187, + 84, + 184, + 195, + 157, + 87, + 159, + 229, + 81, + 138, + 92 + ], + "nonce": [ + 38, + 250, + 51, + 212, + 197, + 179, + 127, + 12, + 93, + 7, + 226, + 208 + ], + "aad": [ + 32, + 150, + 99, + 8, + 245, + 125, + 58, + 62, + 122, + 78, + 161, + 73, + 204, + 31, + 62, + 222, + 174, + 241, + 30, + 138, + 247, + 128, + 161, + 101, + 52, + 71, + 45, + 141, + 247, + 247, + 6, + 21, + 46, + 227, + 118, + 97, + 68, + 38, + 9, + 79, + 215, + 69, + 215, + 124, + 220, + 162, + 134, + 130, + 208, + 210, + 230, + 137, + 210, + 138, + 80, + 97, + 1, + 104, + 214, + 56, + 178, + 60, + 180, + 223, + 250, + 149, + 221, + 38, + 11, + 199, + 46, + 0, + 152, + 114, + 44, + 208, + 1, + 38, + 160, + 127, + 210, + 63, + 251, + 161, + 209, + 10, + 60, + 228, + 107, + 133 + ], + "plaintext": [ + 6, + 207, + 47, + 161, + 201, + 5, + 125, + 73, + 116, + 174, + 144, + 72, + 180, + 135, + 141, + 117, + 176, + 180, + 114, + 14, + 210, + 215, + 195, + 64, + 230, + 217, + 131, + 167, + 207, + 8, + 210, + 0, + 19, + 171, + 238, + 248, + 129, + 204, + 50, + 19, + 254, + 37, + 179, + 246, + 172, + 30, + 23, + 254, + 28, + 46, + 17 + ], + "ciphertext": [ + 97, + 166, + 157, + 53, + 150, + 124, + 133, + 221, + 94, + 7, + 65, + 169, + 184, + 129, + 82, + 195, + 176, + 75, + 24, + 36, + 147, + 12, + 246, + 192, + 63, + 28, + 180, + 76, + 18, + 88, + 183, + 31, + 163, + 245, + 35, + 61, + 47, + 78, + 226, + 86, + 53, + 60, + 11, + 143, + 109, + 71, + 11, + 83, + 215, + 129, + 26 + ], + "tag": [ + 233, + 138, + 122, + 51, + 116, + 141, + 233, + 94, + 34, + 181, + 32, + 186, + 34, + 84, + 188, + 227 + ] + }, + { + "key": [ + 40, + 142, + 126, + 254, + 98, + 185, + 59, + 153, + 15, + 35, + 152, + 194, + 70, + 14, + 65, + 93 + ], + "nonce": [ + 199, + 235, + 192, + 205, + 117, + 109, + 149, + 1, + 250, + 247, + 26, + 125 + ], + "aad": [ + 252, + 178, + 1, + 36, + 197, + 139, + 41, + 239, + 126, + 57, + 128, + 13, + 30, + 17, + 196, + 6, + 55, + 116, + 221, + 44, + 70, + 45, + 217, + 224, + 125, + 20, + 13, + 159, + 75, + 94, + 190, + 76, + 186, + 123, + 184, + 204, + 3, + 191, + 53, + 123, + 34, + 9, + 108, + 152, + 151, + 205, + 205, + 241, + 18, + 183, + 165, + 247, + 209, + 227, + 141, + 92, + 116, + 193, + 105, + 36, + 82, + 44, + 190, + 36, + 67, + 193, + 87, + 204, + 147, + 20, + 108, + 18, + 186, + 228, + 218, + 43, + 47, + 29, + 240, + 127, + 51, + 74, + 161, + 204, + 153, + 253, + 127, + 126, + 40, + 153 + ], + "plaintext": [ + 95, + 175, + 232, + 115, + 185, + 211, + 7, + 113, + 242, + 239, + 141, + 173, + 57, + 122, + 139, + 66, + 175, + 63, + 200, + 247, + 235, + 190, + 168, + 13, + 1, + 50, + 225, + 175, + 20, + 38, + 154, + 70, + 61, + 189, + 135, + 227, + 224, + 26, + 88, + 194, + 217, + 145, + 235, + 59, + 173, + 207, + 21, + 111, + 232, + 38, + 13 + ], + "ciphertext": [ + 229, + 230, + 145, + 0, + 199, + 125, + 87, + 224, + 90, + 65, + 178, + 139, + 231, + 75, + 28, + 133, + 66, + 253, + 31, + 21, + 231, + 63, + 197, + 137, + 83, + 94, + 161, + 250, + 194, + 210, + 99, + 253, + 146, + 205, + 170, + 153, + 8, + 234, + 182, + 255, + 217, + 25, + 69, + 134, + 170, + 63, + 237, + 95, + 205, + 16, + 159 + ], + "tag": [ + 83, + 117, + 22, + 251, + 130, + 124, + 191, + 108, + 224, + 80, + 12, + 111, + 239, + 244, + 219, + 52 + ] + }, + { + "key": [ + 246, + 108, + 91, + 68, + 231, + 169, + 218, + 222, + 87, + 101, + 195, + 246, + 79, + 178, + 186, + 185 + ], + "nonce": [ + 52, + 130, + 164, + 108, + 141, + 79, + 23, + 62, + 98, + 206, + 29, + 197 + ], + "aad": [ + 30, + 119, + 100, + 94, + 250, + 68, + 25, + 178, + 201, + 105, + 107, + 143, + 152, + 144, + 81, + 146, + 154, + 214, + 160, + 31, + 226, + 34, + 58, + 230, + 131, + 37, + 248, + 23, + 108, + 196, + 103, + 255, + 251, + 209, + 152, + 224, + 8, + 144, + 75, + 130, + 175, + 100, + 105, + 163, + 187, + 176, + 149, + 196, + 208, + 12, + 254, + 209, + 67, + 114, + 62, + 214, + 207, + 107, + 164, + 25, + 140, + 64, + 234, + 189, + 5, + 192, + 62, + 2, + 96, + 248, + 178, + 245, + 80, + 56, + 229, + 195, + 130, + 105, + 8, + 134, + 40, + 15, + 105, + 137, + 53, + 124, + 80, + 247, + 79, + 229 + ], + "plaintext": [ + 128, + 80, + 20, + 8, + 226, + 62, + 42, + 101, + 103, + 32, + 179, + 43, + 159, + 65, + 245, + 66, + 252, + 100, + 233, + 232, + 216, + 36, + 175, + 17, + 94, + 206, + 136, + 213, + 81, + 165, + 245, + 213, + 247, + 253, + 182, + 126, + 35, + 57, + 252, + 38, + 61, + 253, + 177, + 138, + 120, + 212, + 35, + 253, + 134, + 140, + 175 + ], + "ciphertext": [ + 231, + 120, + 169, + 70, + 82, + 148, + 68, + 226, + 101, + 101, + 5, + 228, + 245, + 246, + 81, + 157, + 62, + 202, + 213, + 69, + 143, + 143, + 26, + 4, + 243, + 26, + 138, + 249, + 124, + 161, + 133, + 255, + 113, + 119, + 100, + 188, + 166, + 233, + 146, + 88, + 162, + 77, + 201, + 124, + 50, + 42, + 193, + 199, + 245, + 79, + 186 + ], + "tag": [ + 197, + 178, + 203, + 83, + 44, + 208, + 91, + 22, + 43, + 71, + 233, + 79, + 109, + 121, + 203, + 142 + ] + }, + { + "key": [ + 65, + 232, + 175, + 85, + 66, + 110, + 219, + 232, + 240, + 51, + 157, + 15, + 186, + 64, + 4, + 151 + ], + "nonce": [ + 7, + 235, + 135, + 212, + 46, + 144, + 160, + 117, + 212, + 179, + 73, + 17 + ], + "aad": [ + 187, + 46, + 92, + 82, + 242, + 234, + 204, + 155, + 119, + 6, + 162, + 239, + 228, + 182, + 7, + 133, + 137, + 34, + 253, + 105, + 20, + 161, + 226, + 45, + 251, + 236, + 171, + 42, + 6, + 70, + 73, + 66, + 247, + 105, + 169, + 197, + 68, + 240, + 70, + 184, + 138, + 117, + 112, + 226, + 207, + 111, + 216, + 20, + 108, + 134, + 178, + 180, + 222, + 203, + 147, + 79, + 4, + 168, + 30, + 109, + 72, + 175, + 251, + 206, + 31, + 83, + 129, + 171, + 49, + 169, + 115, + 107, + 99, + 245, + 164, + 231, + 68, + 115, + 23, + 38, + 163, + 99, + 87, + 232, + 88, + 192, + 152, + 13, + 55, + 50 + ], + "plaintext": [ + 173, + 197, + 80, + 77, + 10, + 151, + 53, + 215, + 183, + 63, + 197, + 59, + 208, + 255, + 96, + 242, + 200, + 129, + 57, + 79, + 222, + 207, + 204, + 227, + 72, + 62, + 254, + 18, + 107, + 241, + 72, + 228, + 141, + 185, + 192, + 253, + 53, + 111, + 130, + 230, + 45, + 116, + 62, + 192, + 159, + 137, + 6, + 67, + 30, + 181, + 224 + ], + "ciphertext": [ + 4, + 13, + 153, + 105, + 139, + 42, + 94, + 1, + 105, + 246, + 249, + 78, + 97, + 21, + 156, + 19, + 95, + 177, + 156, + 89, + 23, + 192, + 21, + 170, + 248, + 235, + 180, + 164, + 81, + 255, + 216, + 52, + 116, + 40, + 235, + 253, + 216, + 12, + 131, + 132, + 29, + 41, + 147, + 24, + 8, + 76, + 119, + 157, + 201, + 27, + 12 + ], + "tag": [ + 161, + 109, + 98, + 103, + 239, + 174, + 236, + 19, + 214, + 188, + 40, + 19, + 22, + 171, + 139, + 231 + ] + }, + { + "key": [ + 187, + 249, + 71, + 192, + 232, + 5, + 172, + 6, + 65, + 213, + 64, + 180, + 113, + 235, + 157, + 38 + ], + "nonce": [ + 181, + 125, + 175, + 0, + 4, + 244, + 56, + 33, + 241, + 186, + 134, + 222 + ], + "aad": [ + 225, + 141, + 134, + 29, + 201, + 187, + 53, + 169, + 239, + 166, + 60, + 124, + 29, + 234, + 245, + 57, + 16, + 37, + 104, + 9, + 164, + 119, + 241, + 195, + 219, + 137, + 59, + 35, + 137, + 241, + 209, + 55, + 101, + 144, + 51, + 165, + 132, + 27, + 136, + 140, + 214, + 73, + 27, + 181, + 116, + 183, + 130, + 222, + 194, + 200, + 64, + 246, + 53, + 8, + 37, + 64, + 99, + 135, + 215, + 19, + 64, + 210, + 117, + 230, + 42, + 243, + 204, + 7, + 12, + 19, + 137, + 55, + 93, + 129, + 206, + 152, + 173, + 55, + 199, + 175, + 202, + 220, + 215, + 159, + 28, + 82, + 10, + 70, + 46, + 125 + ], + "plaintext": [ + 18, + 17, + 233, + 34, + 78, + 187, + 134, + 47, + 45, + 39, + 222, + 105, + 35, + 98, + 50, + 73, + 66, + 218, + 18, + 218, + 68, + 17, + 118, + 196, + 116, + 42, + 34, + 141, + 121, + 40, + 211, + 193, + 251, + 62, + 131, + 198, + 109, + 104, + 198, + 25, + 161, + 9, + 17, + 252, + 46, + 217, + 2, + 38, + 212, + 174, + 72 + ], + "ciphertext": [ + 166, + 246, + 170, + 23, + 80, + 17, + 139, + 64, + 46, + 225, + 181, + 240, + 37, + 210, + 144, + 7, + 227, + 203, + 22, + 42, + 217, + 227, + 99, + 239, + 185, + 239, + 45, + 36, + 200, + 80, + 246, + 45, + 185, + 37, + 187, + 183, + 233, + 168, + 60, + 166, + 205, + 111, + 116, + 37, + 29, + 183, + 38, + 34, + 133, + 123, + 41 + ], + "tag": [ + 167, + 45, + 204, + 41, + 211, + 88, + 247, + 148, + 54, + 31, + 132, + 32, + 44, + 152, + 50, + 249 + ] + }, + { + "key": [ + 165, + 111, + 77, + 230, + 119, + 43, + 18, + 66, + 241, + 223, + 243, + 68, + 236, + 155, + 81, + 45 + ], + "nonce": [ + 148, + 210, + 40, + 8, + 126, + 130, + 30, + 48, + 20, + 9, + 243, + 5 + ], + "aad": [ + 106, + 156, + 97, + 219, + 191, + 170, + 32, + 161, + 51, + 32, + 165, + 241, + 222, + 173, + 40, + 191, + 190, + 93, + 203, + 232, + 79, + 224, + 163, + 97, + 124, + 52, + 139, + 215, + 2, + 251, + 231, + 70, + 244, + 57, + 223, + 202, + 189, + 173, + 34, + 172, + 47, + 166, + 41, + 121, + 63, + 84, + 91, + 198, + 132, + 89, + 241, + 192, + 70, + 36, + 83, + 181, + 179, + 27, + 116, + 124, + 61, + 41, + 97, + 79, + 12, + 205, + 7, + 69, + 251, + 170, + 75, + 32, + 77, + 71, + 213, + 204, + 125, + 179, + 93, + 107, + 196, + 75, + 252, + 236, + 223, + 174, + 145, + 15, + 170, + 114 + ], + "plaintext": [ + 175, + 83, + 118, + 130, + 196, + 25, + 235, + 124, + 163, + 254, + 214, + 91, + 204, + 54, + 75, + 1, + 239, + 194, + 69, + 95, + 246, + 81, + 40, + 222, + 220, + 136, + 242, + 34, + 70, + 3, + 239, + 61, + 114, + 70, + 98, + 34, + 105, + 161, + 43, + 38, + 155, + 191, + 106, + 201, + 210, + 211, + 184, + 26, + 189, + 54, + 111 + ], + "ciphertext": [ + 85, + 182, + 5, + 135, + 235, + 135, + 145, + 5, + 206, + 74, + 54, + 85, + 93, + 143, + 121, + 150, + 24, + 35, + 139, + 241, + 247, + 253, + 77, + 246, + 34, + 102, + 43, + 208, + 127, + 69, + 10, + 24, + 55, + 90, + 183, + 238, + 240, + 42, + 128, + 54, + 71, + 4, + 40, + 196, + 131, + 79, + 136, + 27, + 240, + 92, + 212 + ], + "tag": [ + 140, + 190, + 72, + 212, + 107, + 92, + 18, + 150, + 176, + 91, + 43, + 111, + 75, + 36, + 247, + 198 + ] + }, + { + "key": [ + 118, + 96, + 103, + 250, + 143, + 13, + 195, + 72, + 183, + 125, + 85, + 171, + 83, + 23, + 166, + 9 + ], + "nonce": [ + 135, + 22, + 33, + 153, + 83, + 190, + 204, + 45, + 137, + 24, + 243, + 170 + ], + "aad": [ + 129, + 6, + 249, + 202, + 203, + 137, + 77, + 194, + 240, + 201, + 60, + 103, + 204, + 6, + 205, + 84, + 175, + 108, + 109, + 148, + 25, + 59, + 208, + 189, + 150, + 115, + 252, + 112, + 47, + 198, + 185, + 149, + 148, + 20, + 118, + 242, + 220, + 88, + 79, + 247, + 83, + 205, + 242, + 69, + 23, + 194, + 21, + 63, + 30, + 28, + 110, + 55, + 254, + 109, + 134, + 193, + 228, + 252, + 99, + 188, + 235, + 37, + 116, + 159, + 147, + 114, + 214, + 42, + 25, + 50, + 116, + 157, + 210, + 30, + 246, + 1, + 11, + 41, + 66, + 189, + 4, + 100, + 189, + 100, + 23, + 16, + 99, + 167, + 120, + 160 + ], + "plaintext": [ + 171, + 145, + 15, + 115, + 0, + 236, + 107, + 245, + 125, + 123, + 175, + 43, + 68, + 116, + 162, + 106, + 125, + 125, + 252, + 214, + 177, + 4, + 76, + 208, + 176, + 179, + 41, + 149, + 2, + 154, + 112, + 98, + 127, + 141, + 37, + 84, + 66, + 158, + 19, + 209, + 77, + 120, + 149, + 15, + 177, + 199, + 158, + 209, + 244, + 140, + 50 + ], + "ciphertext": [ + 139, + 200, + 34, + 24, + 63, + 158, + 66, + 240, + 84, + 41, + 224, + 100, + 147, + 77, + 159, + 132, + 223, + 225, + 113, + 61, + 113, + 105, + 14, + 104, + 152, + 31, + 148, + 37, + 111, + 164, + 166, + 7, + 54, + 96, + 124, + 88, + 100, + 227, + 176, + 94, + 55, + 48, + 202, + 237, + 128, + 0, + 74, + 155, + 179, + 173, + 182 + ], + "tag": [ + 67, + 155, + 11, + 205, + 210, + 74, + 135, + 66, + 154, + 64, + 152, + 253, + 138, + 5, + 81, + 76 + ] + }, + { + "key": [ + 85, + 126, + 242, + 30, + 145, + 241, + 8, + 246, + 171, + 69, + 25, + 128, + 131, + 124, + 240, + 41 + ], + "nonce": [ + 172, + 16, + 16, + 246, + 220, + 236, + 113, + 60, + 186, + 23, + 203, + 19 + ], + "aad": [ + 93, + 9, + 170, + 42, + 48, + 46, + 62, + 194, + 189, + 113, + 178, + 93, + 82, + 5, + 52, + 99, + 201, + 195, + 138, + 59, + 70, + 15, + 123, + 152, + 10, + 173, + 108, + 145, + 213, + 1, + 21, + 112, + 190, + 140, + 35, + 180, + 219, + 81, + 135, + 1, + 244, + 197, + 161, + 87, + 136, + 38, + 149, + 186, + 74, + 193, + 64, + 249, + 75, + 218, + 19, + 217, + 130, + 74, + 137, + 118, + 212, + 54, + 73, + 43, + 170, + 174, + 108, + 79, + 131, + 103, + 104, + 49, + 153, + 105, + 90, + 31, + 107, + 205, + 162, + 246, + 69, + 177, + 136, + 170, + 92, + 40, + 111, + 185, + 28, + 138 + ], + "plaintext": [ + 162, + 174, + 131, + 133, + 50, + 206, + 191, + 201, + 255, + 143, + 182, + 34, + 66, + 184, + 77, + 247, + 6, + 173, + 23, + 119, + 166, + 47, + 84, + 198, + 77, + 155, + 23, + 119, + 189, + 192, + 129, + 148, + 56, + 211, + 74, + 164, + 193, + 144, + 110, + 15, + 174, + 30, + 132, + 91, + 50, + 216, + 251, + 101, + 118, + 61, + 198 + ], + "ciphertext": [ + 148, + 193, + 148, + 24, + 135, + 255, + 148, + 243, + 76, + 185, + 108, + 255, + 43, + 106, + 37, + 246, + 96, + 206, + 155, + 58, + 197, + 73, + 99, + 150, + 14, + 112, + 238, + 73, + 80, + 13, + 174, + 106, + 32, + 211, + 48, + 115, + 147, + 243, + 125, + 58, + 74, + 53, + 193, + 59, + 88, + 247, + 191, + 240, + 245, + 222, + 123 + ], + "tag": [ + 149, + 229, + 116, + 247, + 15, + 94, + 250, + 20, + 184, + 238, + 33, + 150, + 25, + 114, + 238, + 60 + ] + }, + { + "key": [ + 85, + 200, + 188, + 176, + 2, + 16, + 144, + 228, + 178, + 199, + 133, + 199, + 156, + 185, + 102, + 184 + ], + "nonce": [ + 94, + 159, + 19, + 19, + 40, + 47, + 115, + 215, + 255, + 185, + 40, + 55 + ], + "aad": [ + 247, + 225, + 74, + 87, + 227, + 187, + 107, + 153, + 134, + 107, + 144, + 87, + 61, + 123, + 195, + 85, + 186, + 235, + 122, + 195, + 71, + 228, + 61, + 11, + 101, + 217, + 126, + 204, + 46, + 185, + 199, + 114, + 64, + 26, + 142, + 60, + 126, + 158, + 40, + 113, + 194, + 183, + 149, + 121, + 212, + 76, + 19, + 158, + 98, + 195, + 59, + 66, + 169, + 224, + 200, + 118, + 134, + 150, + 0, + 9, + 214, + 89, + 213, + 227, + 135, + 78, + 22, + 140, + 51, + 75, + 102, + 80, + 198, + 211, + 97, + 104, + 99, + 55, + 87, + 167, + 194, + 7, + 100, + 35, + 44, + 233, + 74, + 13, + 225, + 165 + ], + "plaintext": [ + 45, + 124, + 27, + 104, + 145, + 137, + 187, + 250, + 43, + 226, + 106, + 213, + 193, + 242, + 150, + 222, + 228, + 192, + 246, + 20, + 86, + 255, + 201, + 76, + 248, + 231, + 10, + 173, + 15, + 9, + 208, + 96, + 140, + 65, + 21, + 170, + 110, + 213, + 235, + 169, + 62, + 213, + 130, + 11, + 63, + 52, + 38, + 187, + 244, + 214, + 74 + ], + "ciphertext": [ + 186, + 89, + 0, + 45, + 243, + 57, + 76, + 91, + 128, + 152, + 53, + 25, + 220, + 22, + 62, + 202, + 92, + 68, + 223, + 128, + 248, + 196, + 196, + 225, + 93, + 63, + 247, + 63, + 19, + 193, + 112, + 200, + 10, + 89, + 216, + 122, + 33, + 101, + 167, + 180, + 80, + 190, + 1, + 3, + 26, + 142, + 65, + 197, + 5, + 200, + 159 + ], + "tag": [ + 40, + 65, + 140, + 86, + 71, + 49, + 189, + 223, + 61, + 80, + 77, + 142, + 211, + 46, + 102, + 238 + ] + } +] diff --git a/tests/unit_node/crypto/gcmEncryptExtIV256.json b/tests/unit_node/crypto/gcmEncryptExtIV256.json new file mode 100644 index 000000000..cb8ba3086 --- /dev/null +++ b/tests/unit_node/crypto/gcmEncryptExtIV256.json @@ -0,0 +1,57377 @@ +[ + { + "key": [ + 181, + 44, + 80, + 90, + 55, + 215, + 142, + 218, + 93, + 211, + 79, + 32, + 194, + 37, + 64, + 234, + 27, + 88, + 150, + 60, + 248, + 229, + 191, + 143, + 250, + 133, + 249, + 242, + 73, + 37, + 5, + 180 + ], + "nonce": [ + 81, + 108, + 51, + 146, + 157, + 245, + 163, + 40, + 79, + 244, + 99, + 215 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 189, + 193, + 172, + 136, + 77, + 51, + 36, + 87, + 161, + 210, + 102, + 79, + 22, + 140, + 118, + 240 + ] + }, + { + "key": [ + 95, + 224, + 134, + 28, + 220, + 38, + 144, + 206, + 105, + 179, + 101, + 140, + 127, + 38, + 248, + 69, + 142, + 236, + 28, + 146, + 67, + 197, + 186, + 8, + 69, + 48, + 93, + 137, + 126, + 150, + 202, + 15 + ], + "nonce": [ + 119, + 10, + 193, + 165, + 163, + 212, + 118, + 213, + 217, + 105, + 68, + 161 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 25, + 109, + 105, + 30, + 16, + 71, + 9, + 60, + 164, + 179, + 210, + 239, + 75, + 171, + 162, + 22 + ] + }, + { + "key": [ + 118, + 32, + 183, + 155, + 23, + 178, + 27, + 6, + 217, + 112, + 25, + 170, + 112, + 225, + 202, + 16, + 94, + 28, + 3, + 210, + 160, + 207, + 139, + 32, + 181, + 160, + 206, + 92, + 57, + 3, + 229, + 72 + ], + "nonce": [ + 96, + 245, + 110, + 183, + 164, + 179, + 141, + 79, + 3, + 57, + 85, + 17 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 245, + 112, + 195, + 130, + 2, + 217, + 69, + 100, + 186, + 179, + 159, + 117, + 97, + 123, + 200, + 122 + ] + }, + { + "key": [ + 126, + 45, + 176, + 3, + 33, + 24, + 148, + 118, + 209, + 68, + 197, + 242, + 126, + 120, + 112, + 135, + 48, + 42, + 72, + 181, + 247, + 120, + 108, + 217, + 30, + 147, + 100, + 22, + 40, + 194, + 50, + 139 + ], + "nonce": [ + 234, + 157, + 82, + 91, + 240, + 29, + 231, + 178, + 35, + 75, + 96, + 106 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 219, + 157, + 245, + 241, + 79, + 108, + 159, + 42, + 232, + 31, + 212, + 33, + 65, + 45, + 219, + 187 + ] + }, + { + "key": [ + 162, + 61, + 251, + 132, + 181, + 151, + 107, + 70, + 177, + 131, + 13, + 147, + 188, + 246, + 25, + 65, + 202, + 229, + 228, + 9, + 228, + 245, + 85, + 29, + 198, + 132, + 189, + 206, + 249, + 135, + 100, + 128 + ], + "nonce": [ + 90, + 163, + 69, + 144, + 128, + 72, + 222, + 16, + 162, + 189, + 61, + 50 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 242, + 130, + 23, + 100, + 146, + 48, + 189, + 122, + 64, + 169, + 164, + 221, + 171, + 198, + 124, + 67 + ] + }, + { + "key": [ + 223, + 233, + 40, + 248, + 100, + 48, + 183, + 138, + 221, + 123, + 183, + 105, + 96, + 35, + 230, + 21, + 61, + 118, + 151, + 126, + 86, + 16, + 59, + 24, + 2, + 83, + 73, + 10, + 255, + 185, + 67, + 28 + ], + "nonce": [ + 29, + 208, + 120, + 90, + 249, + 245, + 137, + 121, + 161, + 11, + 214, + 45 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 165, + 94, + 176, + 158, + 158, + 222, + 245, + 141, + 159, + 103, + 29, + 114, + 32, + 127, + 139, + 60 + ] + }, + { + "key": [ + 52, + 4, + 141, + 184, + 21, + 145, + 238, + 104, + 34, + 73, + 86, + 189, + 105, + 137, + 225, + 99, + 15, + 207, + 6, + 141, + 127, + 247, + 38, + 174, + 129, + 229, + 178, + 159, + 84, + 140, + 252, + 251 + ], + "nonce": [ + 22, + 33, + 211, + 76, + 255, + 42, + 91, + 37, + 12, + 123, + 118, + 252 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 73, + 146, + 236, + 61, + 87, + 204, + 207, + 165, + 143, + 216, + 145, + 108, + 89, + 183, + 11, + 17 + ] + }, + { + "key": [ + 161, + 17, + 79, + 135, + 73, + 199, + 43, + 140, + 239, + 98, + 231, + 80, + 63, + 26, + 217, + 33, + 211, + 62, + 238, + 222, + 50, + 176, + 181, + 184, + 224, + 214, + 128, + 122, + 162, + 51, + 208, + 173 + ], + "nonce": [ + 161, + 144, + 237, + 63, + 242, + 226, + 56, + 190, + 86, + 249, + 11, + 214 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 200, + 70, + 77, + 149, + 213, + 64, + 251, + 25, + 17, + 86, + 251, + 188, + 22, + 8, + 132, + 42 + ] + }, + { + "key": [ + 221, + 187, + 153, + 220, + 49, + 2, + 211, + 17, + 2, + 192, + 225, + 75, + 35, + 133, + 24, + 96, + 87, + 102, + 197, + 178, + 61, + 155, + 234, + 82, + 199, + 197, + 167, + 113, + 4, + 44, + 133, + 160 + ], + "nonce": [ + 149, + 209, + 94, + 215, + 92, + 106, + 16, + 154, + 172, + 27, + 29, + 134 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 129, + 61, + 29, + 163, + 119, + 92, + 172, + 215, + 142, + 150, + 216, + 111, + 3, + 108, + 255, + 150 + ] + }, + { + "key": [ + 31, + 170, + 80, + 107, + 143, + 19, + 162, + 230, + 102, + 10, + 247, + 141, + 146, + 145, + 90, + 223, + 51, + 54, + 88, + 247, + 72, + 244, + 228, + 143, + 162, + 1, + 53, + 162, + 158, + 154, + 190, + 95 + ], + "nonce": [ + 229, + 15, + 39, + 141, + 54, + 98, + 201, + 157, + 117, + 15, + 96, + 211 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 174, + 199, + 236, + 230, + 107, + 115, + 68, + 175, + 214, + 246, + 204, + 116, + 25, + 207, + 96, + 39 + ] + }, + { + "key": [ + 243, + 11, + 89, + 66, + 250, + 245, + 125, + 76, + 19, + 231, + 168, + 36, + 149, + 174, + 223, + 27, + 78, + 96, + 53, + 57, + 178, + 225, + 89, + 147, + 23, + 204, + 110, + 83, + 34, + 90, + 36, + 147 + ], + "nonce": [ + 51, + 108, + 56, + 142, + 24, + 230, + 171, + 249, + 43, + 183, + 57, + 169 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 221, + 175, + 142, + 244, + 203, + 47, + 138, + 109, + 64, + 31, + 59, + 229, + 255, + 11, + 175, + 106 + ] + }, + { + "key": [ + 218, + 244, + 217, + 193, + 44, + 93, + 41, + 252, + 63, + 169, + 54, + 83, + 44, + 150, + 25, + 110, + 86, + 174, + 132, + 46, + 71, + 6, + 58, + 75, + 41, + 191, + 255, + 42, + 53, + 237, + 146, + 128 + ], + "nonce": [ + 83, + 129, + 242, + 17, + 151, + 224, + 147, + 185, + 108, + 218, + 196, + 250 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 127, + 24, + 50, + 199, + 247, + 205, + 120, + 18, + 160, + 4, + 183, + 156, + 61, + 57, + 148, + 115 + ] + }, + { + "key": [ + 107, + 82, + 71, + 84, + 20, + 156, + 129, + 64, + 29, + 41, + 164, + 184, + 166, + 244, + 164, + 120, + 51, + 55, + 40, + 6, + 178, + 212, + 8, + 63, + 241, + 127, + 45, + 179, + 191, + 193, + 123, + 202 + ], + "nonce": [ + 172, + 125, + 61, + 97, + 138, + 182, + 144, + 85, + 94, + 194, + 68, + 8 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 219, + 7, + 168, + 133, + 226, + 189, + 57, + 218, + 116, + 17, + 109, + 6, + 195, + 22, + 165, + 201 + ] + }, + { + "key": [ + 207, + 240, + 131, + 48, + 63, + 244, + 10, + 31, + 102, + 196, + 174, + 209, + 172, + 127, + 80, + 98, + 143, + 231, + 233, + 49, + 31, + 93, + 3, + 126, + 191, + 73, + 244, + 164, + 185, + 240, + 34, + 63 + ], + "nonce": [ + 69, + 212, + 110, + 27, + 170, + 220, + 251, + 200, + 240, + 233, + 34, + 255 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 22, + 135, + 198, + 212, + 89, + 234, + 72, + 27, + 248, + 142, + 75, + 34, + 99, + 34, + 121, + 6 + ] + }, + { + "key": [ + 57, + 84, + 246, + 12, + 221, + 187, + 57, + 210, + 216, + 176, + 88, + 173, + 245, + 69, + 213, + 184, + 36, + 144, + 200, + 174, + 146, + 131, + 175, + 165, + 39, + 134, + 137, + 4, + 29, + 65, + 90, + 58 + ], + "nonce": [ + 143, + 179, + 217, + 142, + 242, + 79, + 186, + 3, + 116, + 106, + 200, + 79 + ], + "aad": [], + "plaintext": [], + "ciphertext": [], + "tag": [ + 127, + 177, + 48, + 133, + 93, + 254, + 122, + 55, + 51, + 19, + 54, + 31, + 51, + 245, + 82, + 55 + ] + }, + { + "key": [ + 120, + 220, + 78, + 10, + 175, + 82, + 217, + 53, + 195, + 192, + 30, + 234, + 87, + 66, + 143, + 0, + 202, + 31, + 212, + 117, + 245, + 218, + 134, + 164, + 156, + 141, + 215, + 61, + 104, + 200, + 226, + 35 + ], + "nonce": [ + 215, + 156, + 242, + 45, + 80, + 76, + 199, + 147, + 195, + 251, + 108, + 138 + ], + "aad": [ + 185, + 107, + 170, + 140, + 28, + 117, + 166, + 113, + 191, + 178, + 208, + 141, + 6, + 190, + 95, + 54 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 62, + 93, + 72, + 106, + 162, + 227, + 11, + 34, + 224, + 64, + 184, + 87, + 35, + 160, + 110, + 118 + ] + }, + { + "key": [ + 68, + 87, + 255, + 51, + 104, + 60, + 202, + 108, + 164, + 147, + 135, + 139, + 220, + 0, + 55, + 56, + 147, + 169, + 118, + 52, + 18, + 238, + 248, + 205, + 219, + 84, + 249, + 19, + 24, + 224, + 218, + 136 + ], + "nonce": [ + 105, + 157, + 31, + 41, + 215, + 184, + 197, + 83, + 0, + 187, + 31, + 210 + ], + "aad": [ + 103, + 73, + 218, + 238, + 163, + 103, + 208, + 233, + 128, + 158, + 45, + 194, + 243, + 9, + 230, + 227 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 214, + 12, + 116, + 210, + 81, + 127, + 222, + 74, + 116, + 224, + 205, + 71, + 9, + 237, + 67, + 169 + ] + }, + { + "key": [ + 77, + 1, + 201, + 110, + 249, + 217, + 141, + 79, + 180, + 233, + 182, + 27, + 229, + 239, + 167, + 114, + 201, + 120, + 133, + 69, + 179, + 234, + 195, + 158, + 177, + 202, + 203, + 153, + 122, + 95, + 7, + 146 + ], + "nonce": [ + 50, + 18, + 74, + 77, + 158, + 87, + 106, + 234, + 37, + 137, + 242, + 56 + ], + "aad": [ + 215, + 43, + 173, + 12, + 56, + 73, + 94, + 218, + 80, + 213, + 88, + 17, + 148, + 94, + 226, + 5 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 109, + 99, + 151, + 201, + 226, + 3, + 15, + 91, + 128, + 83, + 191, + 229, + 16, + 243, + 242, + 207 + ] + }, + { + "key": [ + 131, + 120, + 25, + 58, + 76, + 230, + 65, + 128, + 129, + 75, + 214, + 5, + 145, + 209, + 5, + 74, + 4, + 219, + 196, + 218, + 2, + 175, + 222, + 69, + 55, + 153, + 205, + 104, + 136, + 238, + 12, + 108 + ], + "nonce": [ + 189, + 139, + 78, + 53, + 44, + 127, + 105, + 135, + 138, + 71, + 84, + 53 + ], + "aad": [ + 28, + 107, + 52, + 60, + 77, + 4, + 92, + 187, + 165, + 98, + 186, + 227, + 229, + 255, + 27, + 24 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 8, + 51, + 150, + 122, + 106, + 83, + 186, + 36, + 231, + 92, + 3, + 114, + 166, + 161, + 123, + 218 + ] + }, + { + "key": [ + 34, + 252, + 130, + 219, + 91, + 96, + 105, + 152, + 173, + 69, + 9, + 155, + 121, + 120, + 181, + 180, + 249, + 221, + 78, + 166, + 1, + 126, + 87, + 55, + 10, + 197, + 97, + 65, + 202, + 170, + 189, + 18 + ], + "nonce": [ + 136, + 13, + 5, + 197, + 238, + 89, + 158, + 95, + 21, + 30, + 48, + 47 + ], + "aad": [ + 62, + 62, + 181, + 116, + 126, + 57, + 15, + 123, + 200, + 14, + 116, + 130, + 51, + 72, + 79, + 252 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 46, + 18, + 42, + 71, + 142, + 100, + 70, + 50, + 134, + 248, + 180, + 137, + 220, + 221, + 9, + 200 + ] + }, + { + "key": [ + 252, + 0, + 150, + 13, + 221, + 105, + 141, + 53, + 114, + 140, + 90, + 198, + 7, + 89, + 107, + 81, + 179, + 248, + 151, + 65, + 209, + 76, + 37, + 184, + 186, + 218, + 201, + 25, + 118, + 18, + 13, + 153 + ], + "nonce": [ + 164, + 36, + 163, + 42, + 35, + 127, + 13, + 245, + 48, + 240, + 94, + 48 + ], + "aad": [ + 207, + 183, + 224, + 94, + 49, + 87, + 240, + 201, + 5, + 73, + 213, + 199, + 134, + 80, + 99, + 17 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 220, + 220, + 185, + 228, + 0, + 75, + 133, + 42, + 13, + 161, + 43, + 223, + 37, + 91, + 77, + 221 + ] + }, + { + "key": [ + 105, + 116, + 153, + 67, + 9, + 47, + 86, + 5, + 191, + 151, + 30, + 24, + 92, + 25, + 28, + 97, + 130, + 97, + 178, + 199, + 204, + 22, + 147, + 205, + 161, + 8, + 12, + 162, + 253, + 141, + 81, + 17 + ], + "nonce": [ + 189, + 13, + 98, + 192, + 46, + 230, + 130, + 6, + 155, + 209, + 225, + 40 + ], + "aad": [ + 105, + 103, + 220, + 232, + 120, + 240, + 59, + 100, + 59, + 245, + 205, + 186, + 89, + 106, + 122, + 243 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 55, + 143, + 121, + 106, + 229, + 67, + 225, + 178, + 145, + 21, + 204, + 24, + 172, + 209, + 147, + 244 + ] + }, + { + "key": [ + 252, + 72, + 117, + 219, + 132, + 129, + 152, + 52, + 177, + 203, + 67, + 130, + 141, + 47, + 10, + 227, + 71, + 58, + 163, + 128, + 17, + 28, + 39, + 55, + 232, + 42, + 154, + 177, + 31, + 234, + 31, + 25 + ], + "nonce": [ + 218, + 106, + 104, + 77, + 63, + 246, + 58, + 45, + 16, + 157, + 236, + 214 + ], + "aad": [ + 145, + 182, + 250, + 42, + 180, + 222, + 68, + 40, + 47, + 252, + 134, + 200, + 205, + 230, + 231, + 245 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 80, + 78, + 129, + 210, + 231, + 135, + 126, + 77, + 173, + 111, + 49, + 205, + 235, + 7, + 189, + 189 + ] + }, + { + "key": [ + 159, + 159, + 231, + 210, + 162, + 109, + 207, + 89, + 214, + 132, + 241, + 192, + 148, + 91, + 95, + 250, + 254, + 10, + 71, + 70, + 132, + 94, + 211, + 23, + 211, + 95, + 62, + 215, + 108, + 147, + 4, + 77 + ], + "nonce": [ + 19, + 181, + 153, + 113, + 205, + 77, + 211, + 107, + 25, + 172, + 113, + 4 + ], + "aad": [ + 25, + 10, + 105, + 52, + 244, + 95, + 137, + 201, + 0, + 103, + 194, + 246, + 46, + 4, + 197, + 59 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 79, + 99, + 106, + 41, + 75, + 251, + 245, + 31, + 192, + 225, + 49, + 214, + 148, + 213, + 194, + 34 + ] + }, + { + "key": [ + 171, + 145, + 85, + 215, + 216, + 27, + 166, + 243, + 49, + 147, + 105, + 92, + 244, + 86, + 106, + 155, + 110, + 151, + 163, + 228, + 9, + 245, + 113, + 89, + 174, + 108, + 164, + 150, + 85, + 204, + 160, + 113 + ], + "nonce": [ + 38, + 169, + 248, + 214, + 101, + 209, + 99, + 221, + 185, + 45, + 3, + 93 + ], + "aad": [ + 74, + 32, + 58, + 194, + 107, + 149, + 26, + 31, + 103, + 60, + 102, + 5, + 101, + 62, + 192, + 45 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 67, + 126, + 167, + 122, + 56, + 121, + 240, + 16, + 105, + 30, + 40, + 141, + 98, + 105, + 169, + 150 + ] + }, + { + "key": [ + 15, + 28, + 98, + 221, + 128, + 180, + 166, + 208, + 158, + 233, + 215, + 135, + 177, + 176, + 67, + 39, + 170, + 54, + 21, + 41, + 255, + 163, + 64, + 117, + 96, + 65, + 74, + 196, + 123, + 126, + 247, + 188 + ], + "nonce": [ + 200, + 118, + 19, + 163, + 183, + 13, + 42, + 4, + 143, + 50, + 203, + 154 + ], + "aad": [ + 143, + 35, + 212, + 4, + 190, + 45, + 158, + 136, + 141, + 33, + 159, + 27, + 64, + 170, + 41, + 232 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 54, + 216, + 163, + 9, + 172, + 187, + 135, + 22, + 201, + 192, + 140, + 127, + 93, + 228, + 145, + 30 + ] + }, + { + "key": [ + 243, + 233, + 84, + 163, + 137, + 86, + 223, + 137, + 2, + 85, + 240, + 23, + 9, + 228, + 87, + 179, + 63, + 75, + 254, + 126, + 203, + 54, + 208, + 238, + 80, + 242, + 80, + 4, + 113, + 238, + 188, + 222 + ], + "nonce": [ + 151, + 153, + 171, + 211, + 197, + 33, + 16, + 199, + 4, + 176, + 243, + 106 + ], + "aad": [ + 221, + 183, + 1, + 115, + 244, + 65, + 87, + 117, + 91, + 108, + 155, + 112, + 88, + 244, + 12, + 183 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 179, + 35, + 174, + 58, + 188, + 180, + 21, + 199, + 244, + 32, + 135, + 108, + 152, + 15, + 72, + 88 + ] + }, + { + "key": [ + 6, + 37, + 49, + 101, + 52, + 251, + 216, + 47, + 232, + 253, + 234, + 80, + 250, + 87, + 60, + 70, + 32, + 34, + 196, + 47, + 121, + 232, + 178, + 19, + 96, + 229, + 166, + 220, + 230, + 109, + 222, + 40 + ], + "nonce": [ + 218, + 100, + 166, + 116, + 144, + 124, + 214, + 207, + 36, + 143, + 95, + 187 + ], + "aad": [ + 242, + 77, + 72, + 224, + 79, + 90, + 13, + 152, + 123, + 167, + 199, + 69, + 183, + 59, + 3, + 100 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 223, + 54, + 11, + 129, + 15, + 39, + 231, + 148, + 103, + 58, + 139, + 178, + 220, + 13, + 104, + 176 + ] + }, + { + "key": [ + 40, + 240, + 69, + 172, + 124, + 79, + 229, + 212, + 176, + 26, + 157, + 205, + 95, + 26, + 211, + 239, + 255, + 28, + 79, + 23, + 15, + 200, + 171, + 135, + 88, + 217, + 114, + 146, + 134, + 141, + 88, + 40 + ], + "nonce": [ + 93, + 133, + 222, + 149, + 176, + 189, + 196, + 69, + 20, + 20, + 57, + 25 + ], + "aad": [ + 96, + 29, + 33, + 88, + 241, + 122, + 179, + 199, + 180, + 220, + 182, + 149, + 15, + 189, + 205, + 222 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 66, + 195, + 245, + 39, + 65, + 140, + 242, + 195, + 245, + 213, + 1, + 12, + 203, + 168, + 242, + 113 + ] + }, + { + "key": [ + 25, + 49, + 14, + 237, + 95, + 95, + 68, + 235, + 71, + 7, + 92, + 16, + 94, + 179, + 30, + 54, + 187, + 253, + 19, + 16, + 247, + 65, + 185, + 186, + 166, + 106, + 129, + 19, + 141, + 53, + 114, + 66 + ], + "nonce": [ + 161, + 36, + 113, + 32, + 19, + 143, + 164, + 240, + 233, + 108, + 153, + 44 + ], + "aad": [ + 41, + 215, + 70, + 65, + 67, + 51, + 224, + 247, + 43, + 76, + 63, + 68, + 236, + 107, + 254, + 66 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 213, + 153, + 126, + 47, + 149, + 109, + 243, + 250, + 44, + 35, + 136, + 226, + 15, + 48, + 196, + 128 + ] + }, + { + "key": [ + 136, + 108, + 255, + 95, + 62, + 107, + 141, + 14, + 26, + 208, + 163, + 143, + 205, + 178, + 109, + 233, + 126, + 138, + 203, + 231, + 159, + 107, + 237, + 102, + 149, + 154, + 89, + 143, + 165, + 4, + 125, + 101 + ], + "nonce": [ + 58, + 142, + 250, + 28, + 215, + 75, + 186, + 181, + 68, + 143, + 153, + 69 + ], + "aad": [ + 81, + 159, + 238, + 81, + 157, + 37, + 199, + 163, + 4, + 214, + 198, + 170, + 24, + 151, + 238, + 30, + 184, + 197, + 150, + 85 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 246, + 212, + 117, + 5, + 236, + 150, + 201, + 138, + 66, + 220, + 58, + 231, + 25, + 135, + 123, + 135 + ] + }, + { + "key": [ + 105, + 55, + 165, + 125, + 53, + 254, + 109, + 195, + 252, + 66, + 11, + 18, + 59, + 204, + 220, + 232, + 116, + 189, + 76, + 24, + 242, + 231, + 192, + 28, + 226, + 250, + 243, + 61, + 57, + 68, + 253, + 157 + ], + "nonce": [ + 168, + 114, + 71, + 121, + 123, + 117, + 132, + 103, + 185, + 99, + 16, + 243 + ], + "aad": [ + 234, + 217, + 97, + 147, + 154, + 51, + 221, + 87, + 143, + 142, + 147, + 219, + 139, + 40, + 161, + 200, + 83, + 98, + 144, + 95 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 89, + 157, + 227, + 236, + 242, + 44, + 184, + 103, + 240, + 63, + 127, + 109, + 159, + 215, + 66, + 138 + ] + }, + { + "key": [ + 230, + 90, + 51, + 23, + 118, + 201, + 220, + 223, + 94, + 186, + 108, + 89, + 224, + 94, + 192, + 121, + 217, + 116, + 115, + 188, + 220, + 232, + 77, + 175, + 131, + 107, + 227, + 35, + 69, + 98, + 99, + 160 + ], + "nonce": [ + 202, + 115, + 31, + 118, + 141, + 160, + 29, + 2, + 235, + 142, + 114, + 126 + ], + "aad": [ + 215, + 39, + 69, + 134, + 81, + 123, + 241, + 216, + 218, + 134, + 111, + 74, + 71, + 173, + 11, + 207, + 41, + 72, + 168, + 98 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 168, + 171, + 231, + 168, + 8, + 95, + 37, + 19, + 10, + 114, + 6, + 211, + 122, + 138, + 175, + 109 + ] + }, + { + "key": [ + 119, + 187, + 27, + 110, + 248, + 152, + 104, + 60, + 152, + 27, + 47, + 200, + 153, + 49, + 159, + 251, + 182, + 0, + 14, + 220, + 162, + 37, + 102, + 182, + 52, + 219, + 58, + 60, + 128, + 64, + 89, + 229 + ], + "nonce": [ + 53, + 74, + 25, + 40, + 55, + 105, + 179, + 185, + 145, + 176, + 90, + 76 + ], + "aad": [ + 181, + 86, + 98, + 81, + 168, + 168, + 190, + 194, + 18, + 220, + 8, + 17, + 50, + 41, + 255, + 133, + 144, + 22, + 136, + 0 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 229, + 194, + 220, + 207, + 143, + 199, + 242, + 150, + 202, + 201, + 93, + 112, + 113, + 203, + 141, + 125 + ] + }, + { + "key": [ + 42, + 67, + 48, + 141, + 82, + 10, + 89, + 237, + 81, + 228, + 122, + 58, + 145, + 94, + 29, + 191, + 32, + 169, + 31, + 8, + 134, + 80, + 110, + 72, + 26, + 211, + 222, + 101, + 213, + 9, + 117, + 180 + ], + "nonce": [ + 188, + 191, + 153, + 115, + 61, + 142, + 201, + 12, + 178, + 62, + 108, + 230 + ], + "aad": [ + 235, + 136, + 40, + 135, + 41, + 40, + 157, + 38, + 254, + 14, + 117, + 122, + 153, + 173, + 142, + 236, + 150, + 16, + 96, + 83 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 1, + 176, + 25, + 105, + 51, + 170, + 73, + 18, + 62, + 171, + 78, + 21, + 113, + 37, + 3, + 131 + ] + }, + { + "key": [ + 35, + 121, + 179, + 95, + 133, + 16, + 45, + 180, + 231, + 174, + 204, + 82, + 183, + 5, + 188, + 105, + 93, + 71, + 104, + 212, + 18, + 226, + 215, + 190, + 190, + 153, + 146, + 54, + 120, + 57, + 114, + 255 + ], + "nonce": [ + 145, + 137, + 152, + 196, + 128, + 16, + 55, + 177, + 205, + 16, + 47, + 170 + ], + "aad": [ + 179, + 114, + 35, + 9, + 224, + 240, + 102, + 34, + 94, + 141, + 22, + 89, + 8, + 78, + 187, + 7, + 169, + 59, + 67, + 93 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 223, + 177, + 138, + 238, + 153, + 209, + 246, + 127, + 87, + 72, + 212, + 180, + 132, + 60, + 182, + 73 + ] + }, + { + "key": [ + 152, + 179, + 203, + 117, + 55, + 22, + 126, + 109, + 20, + 162, + 168, + 178, + 49, + 15, + 233, + 75, + 113, + 92, + 114, + 159, + 223, + 133, + 33, + 101, + 104, + 21, + 11, + 85, + 109, + 7, + 151, + 186 + ], + "nonce": [ + 188, + 165, + 226, + 229, + 166, + 179, + 15, + 24, + 210, + 99, + 198, + 178 + ], + "aad": [ + 38, + 13, + 61, + 114, + 219, + 112, + 214, + 119, + 164, + 227, + 225, + 243, + 225, + 20, + 49, + 33, + 122, + 46, + 71, + 19 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 214, + 183, + 86, + 15, + 138, + 194, + 240, + 169, + 11, + 173, + 66, + 166, + 160, + 114, + 4, + 188 + ] + }, + { + "key": [ + 48, + 52, + 26, + 224, + 241, + 153, + 177, + 10, + 21, + 23, + 93, + 0, + 145, + 61, + 80, + 41, + 82, + 106, + 183, + 247, + 97, + 192, + 185, + 54, + 167, + 221, + 95, + 27, + 21, + 131, + 66, + 157 + ], + "nonce": [ + 219, + 225, + 9, + 168, + 206, + 95, + 123, + 36, + 30, + 153, + 247, + 175 + ], + "aad": [ + 254, + 75, + 222, + 229, + 202, + 156, + 72, + 6, + 250, + 2, + 71, + 21, + 251, + 246, + 106, + 184, + 69, + 40, + 95, + 167 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 174, + 145, + 218, + 237, + 101, + 142, + 38, + 192, + 209, + 38, + 87, + 81, + 71, + 175, + 152, + 153 + ] + }, + { + "key": [ + 130, + 50, + 182, + 161, + 210, + 227, + 103, + 233, + 206, + 30, + 168, + 212, + 47, + 207, + 200, + 58, + 75, + 200, + 189, + 236, + 70, + 92, + 107, + 163, + 38, + 227, + 83, + 173, + 146, + 85, + 242, + 7 + ], + "nonce": [ + 205, + 47, + 181, + 255, + 156, + 240, + 243, + 152, + 104, + 173, + 134, + 133 + ], + "aad": [ + 2, + 65, + 139, + 61, + 222, + 84, + 146, + 74, + 150, + 40, + 222, + 6, + 0, + 76, + 8, + 130, + 174, + 78, + 195, + 187 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 213, + 48, + 143, + 99, + 112, + 134, + 117, + 206, + 209, + 155, + 39, + 16, + 175, + 210, + 219, + 73 + ] + }, + { + "key": [ + 249, + 161, + 50, + 165, + 10, + 80, + 129, + 69, + 255, + 216, + 41, + 78, + 104, + 148, + 78, + 164, + 54, + 206, + 15, + 154, + 151, + 225, + 129, + 245, + 224, + 214, + 197, + 210, + 114, + 49, + 31, + 193 + ], + "nonce": [ + 137, + 41, + 145, + 181, + 78, + 148, + 185, + 213, + 116, + 66, + 204, + 175 + ], + "aad": [ + 78, + 15, + 189, + 55, + 153, + 218, + 37, + 15, + 162, + 121, + 17, + 183, + 230, + 141, + 118, + 35, + 191, + 230, + 10, + 83 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 137, + 136, + 29, + 95, + 120, + 110, + 109, + 83, + 224, + 209, + 156, + 59, + 78, + 104, + 135, + 216 + ] + }, + { + "key": [ + 14, + 55, + 70, + 229, + 6, + 70, + 51, + 234, + 147, + 17, + 178, + 184, + 66, + 124, + 83, + 106, + 249, + 39, + 23, + 222, + 32, + 238, + 182, + 38, + 13, + 177, + 51, + 60, + 61, + 138, + 129, + 20 + ], + "nonce": [ + 248, + 76, + 58, + 28, + 148, + 83, + 63, + 127, + 37, + 206, + 192, + 172 + ], + "aad": [ + 140, + 13, + 65, + 230, + 19, + 83, + 56, + 200, + 211, + 230, + 62, + 42, + 95, + 160, + 169, + 102, + 126, + 201, + 165, + 128 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 71, + 156, + 207, + 233, + 36, + 29, + 226, + 196, + 116, + 242, + 237, + 235, + 187, + 56, + 92, + 9 + ] + }, + { + "key": [ + 185, + 151, + 233, + 176, + 116, + 106, + 186, + 174, + 214, + 230, + 75, + 99, + 189, + 246, + 72, + 130, + 82, + 106, + 217, + 46, + 36, + 162, + 245, + 100, + 157, + 240, + 85, + 201, + 236, + 15, + 29, + 170 + ], + "nonce": [ + 241, + 65, + 216, + 215, + 27, + 3, + 55, + 85, + 2, + 47, + 10, + 125 + ], + "aad": [ + 104, + 29, + 101, + 131, + 245, + 39, + 177, + 169, + 47, + 102, + 202, + 174, + 155, + 29, + 77, + 2, + 142, + 46, + 99, + 30 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 179, + 4, + 66, + 166, + 57, + 94, + 193, + 50, + 70, + 196, + 139, + 33, + 255, + 198, + 85, + 9 + ] + }, + { + "key": [ + 135, + 102, + 14, + 193, + 112, + 13, + 78, + 159, + 136, + 163, + 35, + 164, + 159, + 11, + 135, + 30, + 106, + 175, + 67, + 74, + 45, + 132, + 72, + 208, + 77, + 74, + 34, + 246, + 86, + 16, + 40, + 224 + ], + "nonce": [ + 42, + 7, + 180, + 37, + 147, + 205, + 36, + 240, + 166, + 254, + 64, + 108 + ], + "aad": [ + 29, + 210, + 57, + 181, + 113, + 133, + 183, + 228, + 87, + 206, + 215, + 62, + 187, + 160, + 67, + 5, + 127, + 4, + 158, + 221 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 223, + 122, + 80, + 16, + 73, + 179, + 122, + 83, + 64, + 152, + 203, + 69, + 203, + 156, + 33, + 183 + ] + }, + { + "key": [ + 234, + 71, + 146, + 225, + 241, + 113, + 123, + 119, + 160, + 13, + 228, + 209, + 9, + 230, + 39, + 84, + 155, + 22, + 92, + 130, + 175, + 53, + 243, + 60, + 167, + 225, + 166, + 184, + 237, + 98, + 241, + 79 + ], + "nonce": [ + 116, + 83, + 204, + 139, + 70, + 254, + 75, + 147, + 188, + 196, + 131, + 129 + ], + "aad": [ + 70, + 217, + 137, + 112, + 166, + 54, + 231, + 205, + 123, + 118, + 252, + 54, + 42, + 232, + 130, + 152, + 67, + 111, + 131, + 79 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 81, + 141, + 186, + 205, + 54, + 190, + 111, + 186, + 92, + 18, + 135, + 22, + 120, + 165, + 85, + 22 + ] + }, + { + "key": [ + 52, + 137, + 44, + 221, + 29, + 72, + 202, + 22, + 111, + 123, + 167, + 49, + 130, + 203, + 151, + 51, + 108, + 44, + 117, + 74, + 193, + 96, + 163, + 227, + 113, + 131, + 214, + 251, + 80, + 120, + 206, + 195 + ], + "nonce": [ + 237, + 49, + 152, + 197, + 134, + 27, + 120, + 199, + 26, + 106, + 78, + 236 + ], + "aad": [ + 166, + 250, + 109, + 13, + 209, + 224, + 185, + 91, + 70, + 9, + 149, + 27, + 187, + 231, + 20, + 222, + 10, + 224, + 204, + 250 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 198, + 56, + 119, + 149, + 9, + 107, + 52, + 142, + 207, + 29, + 31, + 108, + 170, + 163, + 200, + 19 + ] + }, + { + "key": [ + 244, + 6, + 155, + 183, + 57, + 208, + 125, + 12, + 175, + 220, + 188, + 96, + 156, + 160, + 21, + 151, + 249, + 133, + 196, + 61, + 182, + 59, + 186, + 170, + 13, + 235, + 187, + 4, + 211, + 132, + 228, + 156 + ], + "nonce": [ + 210, + 95, + 243, + 15, + 220, + 61, + 70, + 79, + 225, + 115, + 232, + 5 + ], + "aad": [ + 62, + 20, + 73, + 196, + 131, + 127, + 8, + 146, + 249, + 213, + 81, + 39, + 199, + 92, + 75, + 37, + 214, + 155, + 227, + 52, + 186, + 245, + 241, + 147, + 148, + 210, + 216, + 187, + 70, + 12, + 191, + 33, + 32, + 225, + 71, + 54, + 208, + 246, + 52, + 170, + 121, + 47, + 236, + 162, + 14, + 69, + 95, + 17 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 128, + 94, + 194, + 147, + 28, + 33, + 129, + 229, + 191, + 183, + 79, + 160, + 169, + 117, + 240, + 207 + ] + }, + { + "key": [ + 98, + 24, + 157, + 204, + 75, + 235, + 151, + 70, + 45, + 108, + 9, + 39, + 216, + 162, + 112, + 211, + 154, + 27, + 7, + 215, + 45, + 10, + 210, + 136, + 64, + 186, + 221, + 79, + 104, + 207, + 156, + 139 + ], + "nonce": [ + 133, + 159, + 218, + 82, + 71, + 200, + 136, + 130, + 58, + 75, + 128, + 50 + ], + "aad": [ + 178, + 141, + 22, + 33, + 238, + 17, + 15, + 76, + 157, + 112, + 159, + 173, + 118, + 75, + 186, + 45, + 214, + 210, + 145, + 188, + 0, + 55, + 72, + 250, + 172, + 109, + 144, + 25, + 55, + 18, + 13, + 65, + 193, + 183, + 206, + 103, + 99, + 55, + 99, + 233, + 158, + 5, + 199, + 19, + 99, + 252, + 236, + 168 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 39, + 51, + 9, + 7, + 208, + 0, + 40, + 128, + 187, + 180, + 193, + 161, + 210, + 60, + 11, + 226 + ] + }, + { + "key": [ + 89, + 1, + 45, + 133, + 161, + 185, + 10, + 235, + 3, + 89, + 230, + 56, + 76, + 153, + 145, + 231, + 190, + 33, + 147, + 25, + 245, + 184, + 145, + 201, + 44, + 56, + 74, + 222, + 47, + 55, + 24, + 22 + ], + "nonce": [ + 60, + 156, + 222, + 0, + 194, + 57, + 18, + 207, + 249, + 104, + 156, + 124 + ], + "aad": [ + 229, + 218, + 244, + 115, + 164, + 112, + 134, + 11, + 85, + 33, + 10, + 72, + 60, + 13, + 26, + 151, + 141, + 138, + 221, + 132, + 60, + 44, + 9, + 127, + 115, + 163, + 205, + 164, + 154, + 196, + 166, + 20, + 200, + 232, + 135, + 217, + 78, + 102, + 146, + 48, + 157, + 46, + 217, + 126, + 190, + 30, + 175, + 93 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 4, + 130, + 57, + 228, + 229, + 194, + 200, + 179, + 56, + 144, + 167, + 201, + 80, + 205, + 168, + 82 + ] + }, + { + "key": [ + 75, + 224, + 155, + 64, + 138, + 214, + 139, + 137, + 15, + 148, + 190, + 94, + 250, + 127, + 233, + 201, + 23, + 54, + 39, + 18, + 163, + 72, + 12, + 87, + 205, + 56, + 68, + 147, + 95, + 53, + 172, + 183 + ], + "nonce": [ + 143, + 53, + 11, + 211, + 184, + 238, + 161, + 115, + 252, + 115, + 112, + 188 + ], + "aad": [ + 40, + 25, + 214, + 90, + 236, + 148, + 33, + 152, + 202, + 151, + 212, + 67, + 94, + 253, + 157, + 212, + 212, + 57, + 59, + 150, + 207, + 91, + 164, + 79, + 9, + 188, + 228, + 186, + 19, + 95, + 200, + 99, + 110, + 130, + 117, + 220, + 181, + 21, + 65, + 75, + 139, + 239, + 211, + 47, + 145, + 252, + 72, + 34 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 161, + 51, + 203, + 122, + 125, + 4, + 113, + 219, + 172, + 97, + 251, + 65, + 88, + 154, + 46, + 254 + ] + }, + { + "key": [ + 19, + 203, + 150, + 90, + 77, + 157, + 26, + 54, + 239, + 173, + 159, + 108, + 161, + 186, + 118, + 56, + 106, + 91, + 177, + 96, + 216, + 11, + 9, + 23, + 39, + 113, + 2, + 53, + 122, + 199, + 175, + 200 + ], + "nonce": [ + 243, + 19, + 173, + 236, + 66, + 166, + 109, + 19, + 195, + 149, + 129, + 128 + ], + "aad": [ + 113, + 123, + 72, + 53, + 136, + 152, + 229, + 204, + 254, + 164, + 40, + 144, + 73, + 173, + 204, + 27, + 176, + 219, + 59, + 62, + 189, + 23, + 103, + 172, + 36, + 251, + 43, + 125, + 55, + 220, + 128, + 234, + 35, + 22, + 193, + 127, + 20, + 251, + 81, + 181, + 225, + 140, + 213, + 187, + 9, + 175, + 228, + 20 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 129, + 180, + 239, + 122, + 132, + 220, + 74, + 11, + 31, + 221, + 190, + 254, + 55, + 245, + 56, + 82 + ] + }, + { + "key": [ + 210, + 127, + 27, + 235, + 187, + 222, + 240, + 237, + 202, + 57, + 58, + 98, + 97, + 176, + 51, + 138, + 187, + 196, + 145, + 38, + 46, + 171, + 7, + 55, + 245, + 82, + 70, + 69, + 143, + 102, + 104, + 204 + ], + "nonce": [ + 252, + 6, + 47, + 133, + 120, + 134, + 226, + 120, + 243, + 165, + 103, + 210 + ], + "aad": [ + 43, + 174, + 146, + 222, + 166, + 74, + 169, + 145, + 137, + 222, + 142, + 164, + 192, + 70, + 116, + 83, + 6, + 0, + 46, + 2, + 207, + 180, + 106, + 65, + 68, + 76, + 232, + 191, + 204, + 50, + 155, + 212, + 32, + 89, + 99, + 217, + 171, + 83, + 87, + 176, + 38, + 164, + 163, + 75, + 26, + 134, + 23, + 113 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 92, + 90, + 108, + 70, + 19, + 241, + 229, + 34, + 89, + 99, + 48, + 212, + 95, + 36, + 63, + 221 + ] + }, + { + "key": [ + 123, + 77, + 25, + 205, + 53, + 105, + 247, + 76, + 123, + 93, + 246, + 26, + 183, + 131, + 121, + 238, + 107, + 250, + 21, + 16, + 93, + 33, + 177, + 11, + 246, + 9, + 102, + 153, + 83, + 144, + 6, + 208 + ], + "nonce": [ + 251, + 237, + 86, + 149, + 196, + 167, + 57, + 237, + 237, + 151, + 177, + 227 + ], + "aad": [ + 198, + 242, + 229, + 214, + 99, + 191, + 175, + 102, + 141, + 1, + 69, + 80, + 239, + 46, + 102, + 191, + 137, + 151, + 135, + 153, + 167, + 133, + 241, + 242, + 199, + 154, + 44, + 179, + 235, + 63, + 47, + 212, + 7, + 98, + 7, + 213, + 247, + 225, + 194, + 132, + 180, + 175, + 92, + 255, + 196, + 228, + 97, + 152 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 113, + 1, + 180, + 52, + 251, + 144, + 199, + 249, + 91, + 155, + 122, + 13, + 238, + 235, + 92, + 129 + ] + }, + { + "key": [ + 211, + 67, + 20, + 136, + 216, + 240, + 72, + 89, + 11, + 215, + 110, + 198, + 110, + 113, + 66, + 30, + 240, + 159, + 101, + 93, + 124, + 248, + 4, + 59, + 243, + 47, + 117, + 180, + 178, + 231, + 239, + 204 + ], + "nonce": [ + 204, + 118, + 110, + 152, + 180, + 10, + 129, + 81, + 159, + 164, + 99, + 146 + ], + "aad": [ + 147, + 50, + 1, + 121, + 253, + 180, + 12, + 188, + 28, + 207, + 0, + 184, + 114, + 163, + 180, + 165, + 246, + 199, + 11, + 86, + 228, + 58, + 132, + 252, + 172, + 94, + 180, + 84, + 160, + 161, + 154, + 116, + 125, + 69, + 32, + 66, + 97, + 27, + 243, + 187, + 170, + 253, + 146, + 94, + 128, + 111, + 254, + 142 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 58, + 252, + 195, + 54, + 206, + 139, + 113, + 145, + 234, + 176, + 74, + 214, + 121, + 22, + 60, + 42 + ] + }, + { + "key": [ + 164, + 64, + 148, + 140, + 3, + 120, + 86, + 28, + 57, + 86, + 129, + 60, + 3, + 31, + 129, + 87, + 50, + 8, + 199, + 255, + 168, + 21, + 17, + 78, + 242, + 238, + 225, + 235, + 100, + 46, + 116, + 198 + ], + "nonce": [ + 193, + 244, + 255, + 229, + 75, + 134, + 128, + 131, + 46, + 237, + 136, + 25 + ], + "aad": [ + 37, + 52, + 56, + 241, + 50, + 177, + 142, + 132, + 131, + 7, + 69, + 97, + 137, + 140, + 86, + 82, + 180, + 58, + 130, + 204, + 148, + 30, + 139, + 74, + 227, + 126, + 121, + 42, + 142, + 214, + 236, + 92, + 226, + 188, + 236, + 159, + 31, + 252, + 244, + 33, + 110, + 70, + 105, + 99, + 7, + 187, + 119, + 74 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 18, + 148, + 69, + 240, + 163, + 201, + 121, + 161, + 18, + 163, + 175, + 177, + 10, + 36, + 226, + 69 + ] + }, + { + "key": [ + 121, + 135, + 6, + 182, + 81, + 3, + 61, + 158, + 155, + 242, + 206, + 6, + 79, + 177, + 43, + 231, + 223, + 115, + 8, + 207, + 69, + 223, + 68, + 119, + 101, + 136, + 205, + 57, + 28, + 73, + 255, + 133 + ], + "nonce": [ + 90, + 67, + 54, + 138, + 57, + 231, + 255, + 183, + 117, + 237, + 250, + 244 + ], + "aad": [ + 146, + 107, + 116, + 254, + 99, + 129, + 235, + 211, + 87, + 87, + 228, + 46, + 142, + 85, + 118, + 1, + 242, + 40, + 123, + 252, + 19, + 58, + 19, + 253, + 134, + 214, + 28, + 1, + 170, + 132, + 243, + 151, + 19, + 191, + 153, + 168, + 220, + 7, + 184, + 18, + 240, + 39, + 76, + 157, + 50, + 128, + 161, + 56 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 137, + 254, + 72, + 26, + 61, + 149, + 192, + 58, + 10, + 157, + 78, + 227, + 227, + 240, + 237, + 74 + ] + }, + { + "key": [ + 195, + 170, + 42, + 57, + 169, + 254, + 244, + 164, + 102, + 97, + 141, + 18, + 136, + 187, + 98, + 248, + 218, + 123, + 28, + 183, + 96, + 204, + 200, + 241, + 190, + 62, + 153, + 224, + 118, + 240, + 142, + 255 + ], + "nonce": [ + 153, + 101, + 186, + 94, + 35, + 217, + 69, + 61, + 114, + 103, + 202, + 91 + ], + "aad": [ + 147, + 239, + 182, + 162, + 175, + 252, + 48, + 76, + 178, + 93, + 253, + 73, + 170, + 62, + 60, + 205, + 178, + 92, + 234, + 195, + 211, + 206, + 169, + 13, + 217, + 158, + 56, + 151, + 105, + 120, + 33, + 122, + 213, + 242, + 185, + 144, + 209, + 11, + 145, + 114, + 92, + 127, + 210, + 3, + 94, + 204, + 106, + 48 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 0, + 169, + 76, + 24, + 164, + 87, + 45, + 207, + 79, + 158, + 34, + 38, + 160, + 61, + 76, + 7 + ] + }, + { + "key": [ + 20, + 224, + 104, + 88, + 0, + 143, + 126, + 119, + 24, + 106, + 43, + 58, + 121, + 40, + 160, + 199, + 252, + 238, + 34, + 19, + 107, + 195, + 111, + 83, + 85, + 63, + 32, + 250, + 92, + 55, + 237, + 205 + ], + "nonce": [ + 50, + 235, + 224, + 220, + 154, + 218, + 132, + 155, + 94, + 218, + 123, + 72 + ], + "aad": [ + 108, + 1, + 82, + 171, + 250, + 72, + 91, + 140, + 214, + 124, + 21, + 74, + 95, + 4, + 17, + 242, + 33, + 33, + 55, + 151, + 116, + 215, + 69, + 244, + 14, + 229, + 119, + 176, + 40, + 253, + 14, + 24, + 130, + 151, + 88, + 21, + 97, + 174, + 151, + 34, + 35, + 215, + 90, + 36, + 180, + 136, + 174, + 215 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 38, + 37, + 176, + 186, + 110, + 224, + 43, + 88, + 188, + 82, + 158, + 67, + 226, + 235, + 71, + 27 + ] + }, + { + "key": [ + 251, + 181, + 107, + 17, + 197, + 26, + 9, + 60, + 225, + 105, + 166, + 153, + 3, + 153, + 196, + 215, + 65, + 246, + 43, + 60, + 198, + 31, + 158, + 138, + 96, + 154, + 27, + 106, + 232, + 231, + 233, + 101 + ], + "nonce": [ + 156, + 90, + 149, + 50, + 71, + 233, + 26, + 206, + 206, + 185, + 222, + 251 + ], + "aad": [ + 70, + 203, + 92, + 79, + 97, + 121, + 22, + 169, + 177, + 178, + 224, + 50, + 114, + 203, + 5, + 144, + 206, + 113, + 100, + 152, + 83, + 48, + 71, + 215, + 60, + 129, + 228, + 203, + 233, + 39, + 138, + 54, + 134, + 17, + 111, + 86, + 50, + 117, + 62, + 162, + 223, + 82, + 239, + 179, + 85, + 26, + 234, + 45 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 79, + 59, + 130, + 230, + 190, + 79, + 8, + 117, + 96, + 113, + 242, + 196, + 108, + 49, + 254, + 223 + ] + }, + { + "key": [ + 179, + 3, + 191, + 2, + 246, + 168, + 219, + 181, + 188, + 75, + 172, + 202, + 176, + 128, + 13, + 181, + 238, + 6, + 222, + 100, + 142, + 47, + 174, + 41, + 155, + 149, + 241, + 53, + 201, + 177, + 7, + 204 + ], + "nonce": [ + 144, + 100, + 149, + 182, + 126, + 244, + 206, + 0, + 180, + 68, + 34, + 250 + ], + "aad": [ + 135, + 44, + 108, + 55, + 9, + 38, + 83, + 92, + 63, + 161, + 186, + 236, + 3, + 30, + 49, + 231, + 198, + 200, + 40, + 8, + 200, + 160, + 96, + 116, + 45, + 190, + 241, + 20, + 150, + 28, + 49, + 79, + 25, + 134, + 178, + 19, + 26, + 157, + 145, + 243, + 15, + 83, + 6, + 126, + 192, + 18, + 198, + 183 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 100, + 221, + 227, + 113, + 105, + 8, + 45, + 24, + 26, + 105, + 16, + 127, + 96, + 197, + 198, + 187 + ] + }, + { + "key": [ + 41, + 245, + 248, + 7, + 89, + 3, + 6, + 60, + 182, + 215, + 5, + 6, + 105, + 177, + 247, + 78, + 8, + 163, + 247, + 158, + 245, + 102, + 41, + 45, + 253, + 239, + 28, + 6, + 164, + 8, + 225, + 171 + ], + "nonce": [ + 53, + 242, + 92, + 72, + 180, + 181, + 53, + 94, + 120, + 185, + 251, + 58 + ], + "aad": [ + 16, + 126, + 46, + 35, + 21, + 159, + 197, + 192, + 116, + 140, + 167, + 160, + 119, + 229, + 204, + 5, + 63, + 165, + 198, + 130, + 255, + 82, + 105, + 211, + 80, + 238, + 129, + 127, + 139, + 93, + 228, + 211, + 151, + 32, + 65, + 209, + 7, + 177, + 226, + 242, + 229, + 76, + 169, + 59, + 114, + 205, + 4, + 8 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 254, + 229, + 169, + 186, + 235, + 181, + 190, + 1, + 101, + 222, + 170, + 134, + 126, + 150, + 122, + 158 + ] + }, + { + "key": [ + 3, + 204, + 183, + 219, + 199, + 184, + 66, + 84, + 101, + 194, + 195, + 252, + 57, + 237, + 5, + 147, + 146, + 159, + 253, + 2, + 164, + 95, + 245, + 131, + 189, + 137, + 183, + 156, + 111, + 100, + 111, + 233 + ], + "nonce": [ + 253, + 17, + 153, + 133, + 83, + 59, + 213, + 82, + 11, + 48, + 29, + 18 + ], + "aad": [ + 152, + 230, + 140, + 16, + 191, + 75, + 90, + 230, + 45, + 67, + 73, + 40, + 252, + 100, + 5, + 20, + 124, + 99, + 1, + 65, + 115, + 3, + 239, + 58, + 112, + 61, + 207, + 210, + 192, + 195, + 57, + 164, + 208, + 168, + 155, + 210, + 159, + 230, + 31, + 236, + 241, + 6, + 106, + 176, + 109, + 122, + 92, + 49, + 164, + 143, + 251, + 254, + 210, + 47, + 116, + 155, + 23, + 233, + 189, + 13, + 193, + 198, + 248, + 251, + 214, + 253, + 69, + 135, + 24, + 77, + 185, + 100, + 213, + 69, + 97, + 50, + 16, + 109, + 120, + 35, + 56, + 195, + 241, + 23, + 236, + 5, + 34, + 155, + 8, + 153 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 207, + 84, + 231, + 20, + 19, + 73, + 182, + 111, + 36, + 129, + 84, + 66, + 120, + 16, + 200, + 122 + ] + }, + { + "key": [ + 87, + 225, + 18, + 205, + 69, + 242, + 197, + 125, + 219, + 129, + 158, + 166, + 81, + 194, + 6, + 118, + 49, + 99, + 239, + 1, + 108, + 238, + 173, + 92, + 78, + 174, + 64, + 242, + 187, + 224, + 228, + 180 + ], + "nonce": [ + 24, + 128, + 34, + 194, + 18, + 93, + 43, + 31, + 207, + 158, + 71, + 105 + ], + "aad": [ + 9, + 200, + 244, + 69, + 206, + 91, + 113, + 70, + 86, + 149, + 248, + 56, + 196, + 187, + 43, + 0, + 98, + 74, + 28, + 145, + 133, + 163, + 213, + 82, + 84, + 109, + 157, + 46, + 228, + 135, + 0, + 7, + 170, + 243, + 0, + 112, + 8, + 248, + 174, + 154, + 255, + 183, + 88, + 139, + 136, + 208, + 154, + 144, + 229, + 139, + 69, + 127, + 136, + 241, + 227, + 117, + 46, + 63, + 185, + 73, + 206, + 55, + 134, + 112, + 182, + 122, + 149, + 248, + 207, + 127, + 92, + 124, + 235, + 101, + 14, + 253, + 115, + 93, + 188, + 101, + 44, + 174, + 6, + 229, + 70, + 165, + 219, + 216, + 97, + 189 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 158, + 252, + 221, + 250, + 11, + 226, + 21, + 130, + 160, + 87, + 73, + 244, + 5, + 13, + 41, + 254 + ] + }, + { + "key": [ + 164, + 221, + 243, + 202, + 183, + 69, + 58, + 174, + 250, + 214, + 22, + 253, + 101, + 214, + 61, + 19, + 0, + 94, + 148, + 89, + 193, + 125, + 49, + 115, + 205, + 110, + 215, + 242, + 168, + 108, + 146, + 31 + ], + "nonce": [ + 6, + 23, + 123, + 36, + 197, + 143, + 59, + 228, + 243, + 221, + 73, + 32 + ], + "aad": [ + 249, + 91, + 4, + 109, + 128, + 72, + 94, + 65, + 28, + 86, + 184, + 52, + 32, + 157, + 58, + 189, + 90, + 138, + 157, + 223, + 114, + 177, + 185, + 22, + 103, + 154, + 223, + 221, + 232, + 147, + 4, + 67, + 21, + 165, + 244, + 150, + 127, + 208, + 64, + 94, + 194, + 151, + 170, + 51, + 47, + 103, + 111, + 240, + 250, + 91, + 215, + 149, + 235, + 96, + 155, + 46, + 79, + 8, + 141, + 177, + 205, + 243, + 124, + 207, + 240, + 115, + 90, + 94, + 83, + 196, + 193, + 33, + 115, + 160, + 2, + 106, + 234, + 66, + 56, + 138, + 125, + 113, + 83, + 168, + 131, + 11, + 138, + 144, + 28, + 249 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 157, + 27, + 216, + 236, + 179, + 39, + 105, + 6, + 19, + 141, + 11, + 3, + 252, + 184, + 193, + 187 + ] + }, + { + "key": [ + 36, + 169, + 43, + 36, + 232, + 89, + 3, + 205, + 74, + 170, + 191, + 224, + 124, + 49, + 13, + 245, + 164, + 248, + 244, + 89, + 224, + 58, + 99, + 203, + 209, + 180, + 120, + 85, + 176, + 156, + 11, + 232 + ], + "nonce": [ + 34, + 231, + 86, + 220, + 137, + 141, + 76, + 241, + 34, + 8, + 6, + 18 + ], + "aad": [ + 46, + 1, + 178, + 83, + 109, + 190, + 55, + 107, + 225, + 68, + 41, + 111, + 92, + 56, + 251, + 9, + 158, + 0, + 143, + 150, + 43, + 159, + 14, + 137, + 99, + 52, + 182, + 64, + 131, + 147, + 191, + 241, + 2, + 10, + 14, + 68, + 36, + 119, + 171, + 253, + 177, + 114, + 114, + 19, + 182, + 204, + 197, + 119, + 245, + 225, + 108, + 176, + 87, + 200, + 148, + 90, + 7, + 227, + 7, + 38, + 75, + 101, + 151, + 154, + 237, + 150, + 181, + 153, + 95, + 64, + 37, + 15, + 251, + 170, + 161, + 161, + 240, + 236, + 207, + 57, + 64, + 21, + 246, + 41, + 15, + 94, + 100, + 223, + 229, + 202 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 13, + 127, + 26, + 237, + 71, + 8, + 160, + 59, + 12, + 128, + 178, + 161, + 135, + 133, + 201, + 109 + ] + }, + { + "key": [ + 21, + 39, + 111, + 198, + 68, + 56, + 87, + 142, + 14, + 197, + 51, + 102, + 185, + 10, + 14, + 35, + 217, + 57, + 16, + 254, + 193, + 13, + 195, + 0, + 61, + 155, + 63, + 63, + 167, + 45, + 183, + 2 + ], + "nonce": [ + 197, + 233, + 49, + 148, + 109, + 92, + 174, + 188, + 34, + 118, + 86, + 210 + ], + "aad": [ + 63, + 150, + 124, + 131, + 186, + 2, + 231, + 124, + 20, + 233, + 212, + 17, + 133, + 235, + 135, + 241, + 114, + 37, + 14, + 147, + 237, + 176, + 248, + 43, + 103, + 66, + 193, + 36, + 41, + 138, + 182, + 148, + 24, + 53, + 142, + 221, + 239, + 163, + 159, + 237, + 195, + 202, + 222, + 157, + 128, + 240, + 54, + 216, + 100, + 165, + 158, + 173, + 55, + 200, + 119, + 39, + 197, + 108, + 112, + 26, + 140, + 217, + 99, + 68, + 105, + 255, + 49, + 199, + 4, + 245, + 238, + 57, + 53, + 65, + 87, + 230, + 85, + 132, + 103, + 185, + 40, + 36, + 218, + 54, + 177, + 192, + 113, + 190, + 223, + 233 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 160, + 255, + 161, + 154, + 220, + 243, + 29, + 6, + 28, + 208, + 221, + 70, + 210, + 64, + 21, + 239 + ] + }, + { + "key": [ + 236, + 9, + 128, + 74, + 4, + 139, + 184, + 84, + 199, + 22, + 24, + 181, + 163, + 161, + 197, + 144, + 145, + 15, + 200, + 166, + 132, + 85, + 19, + 155, + 113, + 148, + 134, + 210, + 40, + 14, + 165, + 154 + ], + "nonce": [ + 208, + 177, + 36, + 126, + 113, + 33, + 169, + 39, + 106, + 193, + 140, + 163 + ], + "aad": [ + 102, + 177, + 211, + 157, + 65, + 69, + 150, + 48, + 142, + 134, + 107, + 4, + 71, + 110, + 5, + 59, + 113, + 172, + 209, + 205, + 7, + 206, + 128, + 147, + 149, + 119, + 235, + 190, + 172, + 224, + 67, + 15, + 126, + 76, + 12, + 24, + 95, + 225, + 217, + 122, + 199, + 86, + 153, + 80, + 200, + 61, + 180, + 11, + 190, + 208, + 241, + 209, + 115, + 225, + 170, + 13, + 194, + 139, + 71, + 115, + 112, + 80, + 50, + 217, + 117, + 81, + 247, + 252, + 239, + 127, + 85, + 228, + 182, + 159, + 136, + 223, + 101, + 0, + 50, + 223, + 197, + 35, + 44, + 21, + 102, + 65, + 16, + 75, + 83, + 151 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 132, + 64, + 230, + 216, + 100, + 171, + 119, + 143, + 155, + 228, + 120, + 242, + 3, + 22, + 45, + 134 + ] + }, + { + "key": [ + 74, + 223, + 134, + 191, + 165, + 71, + 114, + 94, + 75, + 128, + 54, + 90, + 90, + 50, + 124, + 16, + 112, + 64, + 250, + 207, + 255, + 0, + 125, + 195, + 81, + 2, + 6, + 107, + 214, + 169, + 149, + 196 + ], + "nonce": [ + 177, + 1, + 140, + 195, + 49, + 145, + 18, + 85, + 165, + 90, + 7, + 149 + ], + "aad": [ + 5, + 60, + 164, + 66, + 140, + 153, + 11, + 68, + 86, + 211, + 193, + 137, + 93, + 93, + 82, + 222, + 255, + 103, + 88, + 150, + 222, + 159, + 170, + 83, + 216, + 207, + 36, + 18, + 85, + 244, + 163, + 29, + 195, + 57, + 159, + 21, + 216, + 59, + 227, + 128, + 37, + 102, + 22, + 229, + 175, + 4, + 58, + 191, + 179, + 117, + 82, + 101, + 90, + 223, + 79, + 46, + 104, + 221, + 162, + 75, + 195, + 115, + 105, + 81, + 19, + 79, + 53, + 157, + 156, + 14, + 40, + 139, + 183, + 152, + 182, + 195, + 234, + 70, + 35, + 146, + 49, + 163, + 203, + 40, + 0, + 102, + 219, + 152, + 98, + 231 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 199, + 66, + 79, + 56, + 8, + 73, + 48, + 191, + 197, + 237, + 193, + 252, + 241, + 231, + 96, + 141 + ] + }, + { + "key": [ + 60, + 146, + 224, + 209, + 227, + 154, + 60, + 118, + 101, + 115, + 196, + 100, + 108, + 118, + 140, + 64, + 44, + 207, + 244, + 138, + 86, + 104, + 42, + 147, + 67, + 53, + 18, + 171, + 240, + 69, + 110, + 0 + ], + "nonce": [ + 213, + 127, + 49, + 158, + 89, + 1, + 145, + 132, + 29, + 43, + 152, + 189 + ], + "aad": [ + 132, + 13, + 147, + 148, + 170, + 36, + 14, + 82, + 186, + 21, + 33, + 81, + 193, + 42, + 205, + 28, + 212, + 72, + 129, + 232, + 84, + 157, + 200, + 50, + 183, + 26, + 69, + 218, + 126, + 252, + 199, + 79, + 183, + 232, + 68, + 217, + 254, + 194, + 94, + 93, + 73, + 123, + 143, + 184, + 244, + 127, + 50, + 140, + 141, + 153, + 4, + 90, + 25, + 227, + 102, + 230, + 206, + 94, + 25, + 220, + 38, + 246, + 122, + 129, + 169, + 79, + 166, + 201, + 124, + 49, + 77, + 136, + 110, + 123, + 86, + 239, + 241, + 68, + 192, + 159, + 111, + 165, + 25, + 219, + 99, + 8, + 188, + 115, + 66, + 46 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 203, + 78, + 247, + 45, + 189, + 164, + 145, + 77, + 116, + 52, + 249, + 104, + 111, + 130, + 62, + 47 + ] + }, + { + "key": [ + 182, + 107, + 163, + 151, + 51, + 136, + 138, + 158, + 10, + 46, + 48, + 69, + 40, + 68, + 22, + 29, + 195, + 60, + 179, + 131, + 192, + 44, + 225, + 108, + 78, + 250, + 213, + 69, + 37, + 9, + 181, + 181 + ], + "nonce": [ + 147, + 124, + 182, + 101, + 227, + 112, + 89, + 178, + 228, + 3, + 89, + 242 + ], + "aad": [ + 219, + 205, + 150, + 148, + 168, + 131, + 72, + 96, + 3, + 78, + 142, + 222, + 58, + 91, + 212, + 25, + 252, + 249, + 28, + 0, + 90, + 217, + 159, + 72, + 138, + 166, + 35, + 245, + 129, + 98, + 32, + 147, + 249, + 212, + 30, + 106, + 104, + 226, + 15, + 210, + 2, + 243, + 2, + 188, + 252, + 68, + 23, + 202, + 137, + 9, + 11, + 252, + 212, + 213, + 34, + 78, + 143, + 244, + 235, + 91, + 186, + 228, + 236, + 178, + 123, + 170, + 35, + 159, + 89, + 194, + 249, + 156, + 212, + 124, + 10, + 38, + 156, + 73, + 121, + 6, + 180, + 26, + 143, + 50, + 10, + 61, + 210, + 220, + 45, + 226 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 189, + 200, + 36, + 147, + 2, + 217, + 214, + 102, + 207, + 113, + 104, + 49, + 124, + 17, + 135, + 67 + ] + }, + { + "key": [ + 47, + 159, + 205, + 16, + 67, + 69, + 86, + 149, + 99, + 140, + 153, + 26, + 27, + 29, + 53, + 173, + 87, + 193, + 142, + 240, + 114, + 115, + 34, + 116, + 123, + 121, + 145, + 171, + 195, + 215, + 135, + 243 + ], + "nonce": [ + 208, + 108, + 245, + 72, + 246, + 40, + 105, + 244, + 190, + 215, + 163, + 24 + ], + "aad": [ + 67, + 32, + 35, + 193, + 44, + 241, + 246, + 20, + 225, + 0, + 81, + 18, + 161, + 125, + 190, + 108, + 93, + 84, + 2, + 42, + 149, + 207, + 99, + 53, + 165, + 188, + 85, + 0, + 76, + 117, + 240, + 154, + 86, + 153, + 115, + 158, + 207, + 146, + 142, + 28, + 120, + 208, + 61, + 173, + 80, + 150, + 161, + 122, + 8, + 74, + 254, + 28, + 194, + 32, + 65, + 187, + 223, + 181, + 152, + 91, + 208, + 139, + 13, + 204, + 89, + 210, + 176, + 140, + 216, + 107, + 122, + 173, + 89, + 124, + 76, + 215, + 180, + 186, + 109, + 106, + 115, + 112, + 184, + 57, + 149, + 166, + 81, + 26, + 31, + 158 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 50, + 46, + 184, + 79, + 182, + 136, + 79, + 16, + 207, + 183, + 102, + 194, + 227, + 236, + 119, + 158 + ] + }, + { + "key": [ + 33, + 197, + 131, + 154, + 99, + 225, + 35, + 12, + 6, + 176, + 134, + 52, + 28, + 150, + 171, + 116, + 88, + 94, + 105, + 188, + 237, + 148, + 51, + 44, + 174, + 177, + 250, + 119, + 213, + 16, + 194, + 79 + ], + "nonce": [ + 90, + 182, + 229, + 237, + 110, + 231, + 51, + 190, + 114, + 80, + 133, + 140 + ], + "aad": [ + 201, + 47, + 8, + 227, + 15, + 103, + 212, + 37, + 22, + 19, + 60, + 72, + 233, + 123, + 101, + 204, + 158, + 18, + 67, + 101, + 225, + 16, + 171, + 165, + 231, + 178, + 203, + 232, + 61, + 235, + 204, + 153, + 237, + 244, + 235, + 0, + 7, + 175, + 5, + 43, + 218, + 34, + 216, + 89, + 0, + 39, + 27, + 24, + 151, + 175, + 79, + 217, + 172, + 230, + 162, + 208, + 157, + 152, + 74, + 195, + 222, + 121, + 208, + 93, + 224, + 177, + 5, + 168, + 27, + 18, + 84, + 43, + 44, + 72, + 226, + 125, + 64, + 159, + 214, + 153, + 45, + 208, + 98, + 214, + 5, + 93, + 111, + 198, + 104, + 66 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 83, + 176, + 228, + 80, + 48, + 157, + 20, + 100, + 89, + 242, + 161, + 228, + 108, + 157, + 158, + 35 + ] + }, + { + "key": [ + 37, + 161, + 68, + 240, + 253, + 186, + 24, + 65, + 37, + 216, + 26, + 135, + 231, + 237, + 130, + 250, + 211, + 60, + 112, + 26, + 9, + 74, + 103, + 168, + 31, + 228, + 105, + 45, + 198, + 154, + 250, + 49 + ], + "nonce": [ + 139, + 245, + 117, + 197, + 194, + 180, + 91, + 78, + 252, + 103, + 70, + 228 + ], + "aad": [ + 42, + 54, + 124, + 176, + 211, + 183, + 197, + 184, + 50, + 11, + 60, + 249, + 94, + 130, + 182, + 186, + 11, + 186, + 29, + 9, + 162, + 5, + 88, + 133, + 222, + 221, + 158, + 245, + 100, + 22, + 35, + 104, + 34, + 18, + 16, + 50, + 56, + 184, + 247, + 117, + 204, + 228, + 45, + 223, + 212, + 246, + 99, + 130, + 242, + 195, + 165, + 232, + 214, + 223, + 249, + 22, + 60, + 237, + 131, + 88, + 10, + 117, + 112, + 85, + 116, + 2, + 107, + 85, + 219, + 144, + 247, + 95, + 138, + 187, + 48, + 20, + 201, + 167, + 7, + 2, + 29, + 237, + 192, + 117, + 218, + 56, + 190, + 187, + 240, + 160 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 14, + 44, + 233, + 202, + 200, + 223, + 206, + 219, + 5, + 114, + 236, + 108, + 171, + 98, + 30, + 253 + ] + }, + { + "key": [ + 66, + 188, + 132, + 27, + 59, + 3, + 168, + 7, + 205, + 54, + 106, + 53, + 236, + 236, + 138, + 106, + 235, + 239, + 124, + 76, + 186, + 14, + 200, + 203, + 141, + 160, + 218, + 65, + 223, + 140, + 206, + 241 + ], + "nonce": [ + 27, + 212, + 111, + 133, + 223, + 95, + 75, + 58, + 18, + 110, + 227, + 21 + ], + "aad": [ + 237, + 227, + 220, + 221, + 189, + 199, + 216, + 229, + 208, + 52, + 192, + 22, + 97, + 51, + 46, + 195, + 73, + 203, + 78, + 122, + 159, + 186, + 175, + 122, + 190, + 44, + 100, + 117, + 135, + 219, + 134, + 205, + 66, + 124, + 230, + 105, + 8, + 224, + 112, + 188, + 73, + 239, + 131, + 135, + 71, + 224, + 107, + 69, + 172, + 72, + 109, + 251, + 234, + 111, + 134, + 152, + 180, + 98, + 94, + 33, + 230, + 157, + 184, + 50, + 126, + 192, + 92, + 253, + 116, + 172, + 203, + 230, + 122, + 182, + 68, + 148, + 140, + 219, + 85, + 74, + 241, + 121, + 161, + 226, + 100, + 224, + 143, + 225, + 102, + 65 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 99, + 58, + 182, + 170, + 245, + 179, + 43, + 83, + 167, + 148, + 246, + 190, + 98, + 98, + 252, + 95 + ] + }, + { + "key": [ + 194, + 91, + 133, + 0, + 190, + 115, + 33, + 5, + 150, + 252, + 74, + 159, + 180, + 216, + 77, + 26, + 51, + 121, + 169, + 30, + 63, + 10, + 108, + 196, + 23, + 125, + 153, + 96, + 70, + 98, + 118, + 121 + ], + "nonce": [ + 181, + 108, + 72, + 192, + 196, + 205, + 49, + 139, + 32, + 67, + 112, + 2 + ], + "aad": [ + 188, + 209, + 77, + 208, + 67, + 253, + 200, + 195, + 39, + 149, + 126, + 28, + 20, + 40, + 105, + 133, + 67, + 236, + 134, + 2, + 82, + 26, + 124, + 116, + 120, + 141, + 41, + 109, + 55, + 212, + 130, + 143, + 16, + 249, + 6, + 86, + 136, + 61, + 37, + 49, + 199, + 2, + 235, + 218, + 45, + 192, + 166, + 141, + 171, + 0, + 21, + 69, + 119, + 69, + 68, + 85, + 250, + 217, + 134, + 255, + 142, + 9, + 115, + 9, + 141, + 191, + 55, + 15, + 247, + 3, + 237, + 152, + 34, + 43, + 148, + 87, + 38, + 237, + 155, + 231, + 144, + 146, + 16, + 221, + 188, + 103, + 46, + 153, + 253, + 217 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 129, + 113, + 212, + 255, + 96, + 254, + 126, + 246, + 222, + 2, + 136, + 50, + 106, + 167, + 50, + 35 + ] + }, + { + "key": [ + 221, + 149, + 37, + 155, + 200, + 238, + 250, + 62, + 73, + 60, + 177, + 166, + 186, + 29, + 142, + 226, + 179, + 65, + 213, + 35, + 13, + 80, + 54, + 48, + 148, + 162, + 204, + 52, + 51, + 179, + 217, + 185 + ], + "nonce": [ + 161, + 166, + 206, + 208, + 132, + 244, + 241, + 57, + 144, + 117, + 10, + 158 + ], + "aad": [ + 212, + 109, + 185, + 14, + 19, + 104, + 75, + 38, + 20, + 156, + 179, + 183, + 247, + 118, + 226, + 40, + 160, + 83, + 143, + 161, + 137, + 44, + 65, + 138, + 170, + 208, + 122, + 160, + 141, + 48, + 118, + 244, + 165, + 43, + 238, + 143, + 19, + 15, + 245, + 96, + 219, + 43, + 141, + 16, + 9, + 233, + 38, + 15, + 166, + 35, + 63, + 194, + 39, + 51, + 224, + 80, + 201, + 228, + 247, + 204, + 105, + 144, + 98, + 118, + 94, + 38, + 29, + 255, + 255, + 17, + 89, + 233, + 6, + 11, + 38, + 200, + 6, + 93, + 250, + 176, + 64, + 85, + 181, + 140, + 130, + 195, + 64, + 217, + 135, + 201 + ], + "plaintext": [], + "ciphertext": [], + "tag": [ + 158, + 18, + 11, + 1, + 137, + 159, + 226, + 203, + 62, + 58, + 11, + 12, + 5, + 4, + 89, + 64 + ] + }, + { + "key": [ + 49, + 189, + 173, + 217, + 102, + 152, + 194, + 4, + 170, + 156, + 225, + 68, + 142, + 169, + 74, + 225, + 251, + 74, + 154, + 11, + 60, + 157, + 119, + 59, + 81, + 187, + 24, + 34, + 102, + 107, + 143, + 34 + ], + "nonce": [ + 13, + 24, + 224, + 108, + 124, + 114, + 90, + 201, + 227, + 98, + 225, + 206 + ], + "aad": [], + "plaintext": [ + 45, + 181, + 22, + 142, + 147, + 37, + 86, + 248, + 8, + 154, + 6, + 34, + 152, + 29, + 1, + 125 + ], + "ciphertext": [ + 250, + 67, + 98, + 24, + 150, + 97, + 209, + 99, + 252, + 214, + 165, + 109, + 139, + 240, + 64, + 90 + ], + "tag": [ + 214, + 54, + 172, + 27, + 190, + 221, + 92, + 195, + 238, + 114, + 125, + 194, + 171, + 74, + 148, + 137 + ] + }, + { + "key": [ + 70, + 15, + 200, + 100, + 151, + 34, + 97, + 194, + 86, + 14, + 30, + 184, + 135, + 97, + 255, + 28, + 153, + 43, + 152, + 36, + 151, + 189, + 42, + 195, + 108, + 4, + 7, + 28, + 187, + 142, + 93, + 153 + ], + "nonce": [ + 138, + 74, + 22, + 185, + 226, + 16, + 235, + 104, + 188, + 182, + 245, + 141 + ], + "aad": [], + "plaintext": [ + 153, + 228, + 233, + 38, + 255, + 233, + 39, + 246, + 145, + 137, + 63, + 183, + 154, + 150, + 176, + 103 + ], + "ciphertext": [ + 19, + 63, + 193, + 87, + 81, + 98, + 27, + 95, + 50, + 92, + 127, + 247, + 28, + 224, + 131, + 36 + ], + "tag": [ + 236, + 78, + 135, + 224, + 207, + 116, + 161, + 54, + 24, + 208, + 182, + 134, + 54, + 186, + 159, + 167 + ] + }, + { + "key": [ + 247, + 138, + 43, + 163, + 197, + 189, + 22, + 77, + 225, + 52, + 160, + 48, + 202, + 9, + 233, + 148, + 99, + 234, + 126, + 150, + 123, + 146, + 196, + 176, + 160, + 135, + 7, + 150, + 72, + 2, + 151, + 229 + ], + "nonce": [ + 43, + 185, + 47, + 203, + 114, + 108, + 39, + 138, + 47, + 163, + 90, + 136 + ], + "aad": [], + "plaintext": [ + 245, + 98, + 80, + 158, + 209, + 57, + 166, + 187, + 231, + 171, + 84, + 90, + 198, + 22, + 37, + 12 + ], + "ciphertext": [ + 226, + 247, + 135, + 153, + 110, + 55, + 211, + 180, + 114, + 148, + 191, + 126, + 187, + 165, + 238, + 37 + ], + "tag": [ + 0, + 246, + 19, + 238, + 233, + 189, + 173, + 108, + 158, + 231, + 118, + 93, + 177, + 203, + 69, + 192 + ] + }, + { + "key": [ + 72, + 230, + 175, + 33, + 45, + 161, + 56, + 101, + 0, + 69, + 76, + 148, + 162, + 1, + 100, + 12, + 33, + 81, + 178, + 128, + 121, + 36, + 14, + 64, + 215, + 45, + 42, + 95, + 215, + 213, + 66, + 52 + ], + "nonce": [ + 239, + 15, + 240, + 98, + 34, + 14, + 184, + 23, + 220, + 46, + 206, + 148 + ], + "aad": [], + "plaintext": [ + 199, + 175, + 238, + 206, + 193, + 64, + 138, + 209, + 85, + 177, + 119, + 194, + 220, + 113, + 56, + 176 + ], + "ciphertext": [ + 148, + 50, + 166, + 32, + 230, + 162, + 35, + 7, + 224, + 106, + 50, + 29, + 102, + 132, + 111, + 212 + ], + "tag": [ + 227, + 234, + 73, + 145, + 146, + 242, + 205, + 141, + 58, + 179, + 237, + 252, + 85, + 137, + 116, + 21 + ] + }, + { + "key": [ + 121, + 205, + 141, + 117, + 15, + 200, + 234, + 98, + 162, + 113, + 78, + 220, + 217, + 179, + 40, + 103, + 199, + 196, + 218, + 144, + 108, + 86, + 226, + 58, + 100, + 69, + 82, + 245, + 184, + 18, + 231, + 90 + ], + "nonce": [ + 155, + 191, + 219, + 129, + 1, + 93, + 43, + 87, + 222, + 173, + 45, + 229 + ], + "aad": [], + "plaintext": [ + 249, + 128, + 173, + 140, + 85, + 235, + 211, + 30, + 230, + 249, + 143, + 68, + 233, + 43, + 255, + 85 + ], + "ciphertext": [ + 65, + 163, + 77, + 30, + 117, + 156, + 133, + 158, + 145, + 184, + 207, + 93, + 61, + 237, + 25, + 112 + ], + "tag": [ + 104, + 205, + 152, + 64, + 109, + 91, + 50, + 37, + 113, + 231, + 80, + 195, + 10, + 164, + 152, + 52 + ] + }, + { + "key": [ + 19, + 10, + 228, + 80, + 193, + 142, + 251, + 133, + 16, + 87, + 170, + 167, + 149, + 117, + 160, + 160, + 144, + 25, + 75, + 232, + 178, + 201, + 84, + 105, + 160, + 232, + 227, + 128, + 168, + 244, + 143, + 66 + ], + "nonce": [ + 178, + 105, + 17, + 83, + 150, + 248, + 27, + 57, + 224, + 195, + 143, + 71 + ], + "aad": [], + "plaintext": [ + 3, + 108, + 243, + 98, + 128, + 222, + 232, + 53, + 92, + 130, + 171, + 196, + 193, + 253, + 183, + 120 + ], + "ciphertext": [ + 9, + 247, + 86, + 143, + 216, + 24, + 22, + 82, + 229, + 86, + 240, + 221, + 165, + 164, + 158, + 213 + ], + "tag": [ + 209, + 11, + 97, + 148, + 124, + 174, + 39, + 91, + 112, + 52, + 245, + 37, + 155, + 166, + 252, + 40 + ] + }, + { + "key": [ + 156, + 113, + 33, + 40, + 154, + 239, + 198, + 112, + 144, + 202, + 190, + 213, + 58, + 209, + 22, + 88, + 190, + 114, + 165, + 55, + 39, + 97, + 185, + 215, + 53, + 232, + 29, + 43, + 252, + 14, + 50, + 103 + ], + "nonce": [ + 173, + 225, + 112, + 45, + 32, + 81, + 184, + 221, + 32, + 59, + 84, + 25 + ], + "aad": [], + "plaintext": [ + 185, + 91, + 202, + 162, + 179, + 20, + 3, + 215, + 104, + 89, + 164, + 195, + 1, + 197, + 11, + 86 + ], + "ciphertext": [ + 98, + 130, + 133, + 230, + 72, + 144, + 144, + 221, + 225, + 185, + 166, + 6, + 116, + 120, + 80, + 3 + ], + "tag": [ + 159, + 81, + 106, + 243, + 243, + 185, + 61, + 97, + 14, + 219, + 197, + 186, + 110, + 45, + 17, + 95 + ] + }, + { + "key": [ + 4, + 0, + 180, + 40, + 151, + 1, + 31, + 194, + 15, + 210, + 40, + 10, + 82, + 239, + 144, + 93, + 110, + 191, + 27, + 5, + 91, + 72, + 201, + 112, + 103, + 189, + 120, + 109, + 103, + 142, + 196, + 234 + ], + "nonce": [ + 10, + 191, + 176, + 164, + 20, + 150, + 180, + 83, + 53, + 132, + 9, + 217 + ], + "aad": [], + "plaintext": [ + 32, + 200, + 35, + 1, + 145, + 227, + 95, + 78, + 155, + 38, + 157, + 89, + 207, + 85, + 33, + 246 + ], + "ciphertext": [ + 221, + 140, + 56, + 8, + 125, + 175, + 251, + 187, + 62, + 187, + 87, + 235, + 245, + 238, + 95, + 120 + ], + "tag": [ + 191, + 176, + 122, + 165, + 4, + 158, + 227, + 80, + 236, + 111, + 177, + 57, + 127, + 55, + 8, + 123 + ] + }, + { + "key": [ + 86, + 105, + 7, + 152, + 151, + 140, + 21, + 79, + 242, + 80, + 186, + 120, + 228, + 99, + 118, + 95, + 47, + 12, + 230, + 151, + 9, + 164, + 85, + 27, + 216, + 203, + 58, + 221, + 237, + 160, + 135, + 182 + ], + "nonce": [ + 207, + 55, + 194, + 134, + 193, + 138, + 212, + 234, + 61, + 11, + 166, + 160 + ], + "aad": [], + "plaintext": [ + 45, + 50, + 129, + 36, + 168, + 213, + 141, + 86, + 208, + 119, + 94, + 237, + 147, + 222, + 26, + 136 + ], + "ciphertext": [ + 59, + 10, + 2, + 103, + 246, + 236, + 222, + 58, + 120, + 179, + 9, + 3, + 235, + 212, + 202, + 110 + ], + "tag": [ + 31, + 210, + 0, + 100, + 9, + 252, + 99, + 99, + 121, + 243, + 212, + 6, + 126, + 202, + 9, + 136 + ] + }, + { + "key": [ + 138, + 2, + 163, + 59, + 223, + 135, + 231, + 132, + 93, + 122, + 138, + 227, + 200, + 114, + 126, + 112, + 79, + 79, + 208, + 140, + 31, + 32, + 131, + 40, + 45, + 140, + 179, + 165, + 211, + 206, + 222, + 233 + ], + "nonce": [ + 89, + 159, + 88, + 150, + 133, + 28, + 150, + 142, + 216, + 8, + 50, + 59 + ], + "aad": [], + "plaintext": [ + 74, + 222, + 139, + 50, + 213, + 103, + 35, + 251, + 143, + 101, + 206, + 64, + 130, + 94, + 39, + 201 + ], + "ciphertext": [ + 203, + 145, + 51, + 121, + 107, + 144, + 117, + 101, + 120, + 64, + 66, + 26, + 70, + 2, + 43, + 99 + ], + "tag": [ + 167, + 158, + 69, + 60, + 111, + 173, + 138, + 90, + 76, + 42, + 142, + 135, + 130, + 28, + 127, + 136 + ] + }, + { + "key": [ + 35, + 170, + 167, + 138, + 89, + 21, + 177, + 79, + 0, + 207, + 40, + 95, + 56, + 238, + 39, + 90, + 45, + 185, + 124, + 180, + 171, + 20, + 209, + 170, + 200, + 185, + 167, + 63, + 241, + 230, + 100, + 103 + ], + "nonce": [ + 74, + 103, + 94, + 201, + 190, + 26, + 171, + 150, + 50, + 221, + 159, + 89 + ], + "aad": [], + "plaintext": [ + 86, + 101, + 156, + 6, + 160, + 10, + 46, + 142, + 209, + 172, + 96, + 87, + 46, + 238, + 62, + 247 + ], + "ciphertext": [ + 230, + 192, + 23, + 35, + 191, + 191, + 163, + 152, + 217, + 201, + 170, + 200, + 198, + 131, + 187, + 18 + ], + "tag": [ + 74, + 47, + 120, + 169, + 151, + 93, + 74, + 27, + 95, + 80, + 58, + 74, + 44, + 183, + 21, + 83 + ] + }, + { + "key": [ + 254, + 100, + 127, + 114, + 233, + 92, + 70, + 144, + 39, + 244, + 215, + 119, + 132, + 41, + 162, + 232, + 233, + 13, + 9, + 2, + 104, + 212, + 250, + 125, + 244, + 79, + 101, + 192, + 175, + 132, + 25, + 10 + ], + "nonce": [ + 79, + 64, + 174, + 42, + 131, + 169, + 180, + 128, + 228, + 104, + 108, + 144 + ], + "aad": [], + "plaintext": [ + 49, + 253, + 108, + 206, + 63, + 13, + 43, + 13, + 24, + 224, + 175, + 1, + 196, + 181, + 96, + 158 + ], + "ciphertext": [ + 84, + 199, + 105, + 253, + 84, + 47, + 13, + 48, + 34, + 241, + 51, + 90, + 124, + 65, + 11, + 97 + ], + "tag": [ + 16, + 108, + 183, + 203, + 205, + 150, + 125, + 166, + 202, + 214, + 70, + 3, + 156, + 117, + 52, + 116 + ] + }, + { + "key": [ + 252, + 226, + 5, + 81, + 95, + 5, + 81, + 177, + 121, + 113, + 40, + 162, + 19, + 45, + 142, + 0, + 46, + 165, + 171, + 27, + 235, + 153, + 197, + 231, + 232, + 50, + 147, + 152, + 207, + 71, + 142, + 16 + ], + "nonce": [ + 32, + 32, + 154, + 13, + 74, + 59, + 155, + 253, + 222, + 239, + 57, + 160 + ], + "aad": [], + "plaintext": [ + 125, + 102, + 62, + 49, + 162, + 246, + 255, + 239, + 23, + 229, + 54, + 104, + 77, + 174, + 46, + 135 + ], + "ciphertext": [ + 101, + 41, + 113, + 32, + 48, + 251, + 101, + 157, + 193, + 26, + 183, + 25, + 246, + 164, + 196, + 2 + ], + "tag": [ + 88, + 105, + 148, + 100, + 208, + 98, + 171, + 165, + 5, + 80, + 140, + 87, + 108, + 78, + 7, + 221 + ] + }, + { + "key": [ + 205, + 51, + 0, + 63, + 241, + 143, + 111, + 51, + 105, + 221, + 154, + 53, + 56, + 18, + 97, + 186, + 102, + 12, + 224, + 167, + 105, + 134, + 68, + 117, + 21, + 46, + 103, + 112, + 102, + 84, + 3, + 55 + ], + "nonce": [ + 32, + 191, + 254, + 144, + 100, + 206, + 118, + 210, + 117, + 32, + 65, + 56 + ], + "aad": [], + "plaintext": [ + 172, + 175, + 83, + 212, + 221, + 47, + 225, + 44, + 212, + 68, + 80, + 176, + 217, + 173, + 204, + 146 + ], + "ciphertext": [ + 166, + 105, + 253, + 160, + 68, + 75, + 24, + 1, + 101, + 249, + 8, + 21, + 220, + 153, + 43, + 51 + ], + "tag": [ + 110, + 49, + 245, + 165, + 108, + 71, + 144, + 206, + 220, + 194, + 54, + 140, + 81, + 208, + 99, + 155 + ] + }, + { + "key": [ + 56, + 24, + 115, + 181, + 249, + 87, + 157, + 130, + 65, + 240, + 198, + 31, + 13, + 158, + 50, + 123, + 185, + 246, + 120, + 105, + 23, + 20, + 170, + 164, + 142, + 167, + 217, + 38, + 120, + 212, + 63, + 231 + ], + "nonce": [ + 63, + 200, + 190, + 194, + 54, + 3, + 21, + 142, + 1, + 45, + 101, + 229 + ], + "aad": [], + "plaintext": [ + 123, + 98, + 46, + 155, + 64, + 143, + 233, + 31, + 111, + 168, + 0, + 236, + 239, + 131, + 141, + 54 + ], + "ciphertext": [ + 140, + 164, + 222, + 91, + 78, + 42, + 178, + 36, + 49, + 160, + 9, + 243, + 221, + 208, + 27, + 174 + ], + "tag": [ + 179, + 167, + 248, + 14, + 62, + 223, + 50, + 38, + 34, + 115, + 21, + 80, + 22, + 76, + 215, + 71 + ] + }, + { + "key": [ + 146, + 225, + 29, + 205, + 170, + 134, + 111, + 92, + 231, + 144, + 253, + 36, + 80, + 31, + 146, + 80, + 154, + 172, + 244, + 203, + 139, + 19, + 57, + 213, + 12, + 156, + 18, + 64, + 147, + 93, + 208, + 139 + ], + "nonce": [ + 172, + 147, + 161, + 166, + 20, + 82, + 153, + 189, + 233, + 2, + 242, + 26 + ], + "aad": [ + 30, + 8, + 137, + 1, + 111, + 103, + 96, + 28, + 142, + 190, + 164, + 148, + 59, + 194, + 58, + 214 + ], + "plaintext": [ + 45, + 113, + 188, + 250, + 145, + 78, + 74, + 192, + 69, + 178, + 170, + 96, + 149, + 95, + 173, + 36 + ], + "ciphertext": [ + 137, + 149, + 174, + 46, + 109, + 243, + 219, + 249, + 111, + 172, + 123, + 113, + 55, + 186, + 230, + 127 + ], + "tag": [ + 236, + 165, + 170, + 119, + 213, + 29, + 74, + 10, + 20, + 217, + 197, + 30, + 29, + 164, + 116, + 171 + ] + }, + { + "key": [ + 125, + 163, + 188, + 202, + 255, + 179, + 70, + 65, + 120, + 202, + 124, + 114, + 35, + 121, + 131, + 109, + 181, + 12, + 224, + 191, + 180, + 118, + 64, + 185, + 87, + 33, + 99, + 134, + 83, + 50, + 228, + 134 + ], + "nonce": [ + 192, + 79, + 210, + 231, + 1, + 195, + 220, + 98, + 182, + 135, + 56, + 179 + ], + "aad": [ + 254, + 192, + 49, + 16, + 19, + 32, + 46, + 79, + 253, + 196, + 32, + 73, + 38, + 174, + 13, + 223 + ], + "plaintext": [ + 253, + 103, + 28, + 171, + 30, + 226, + 31, + 13, + 246, + 187, + 97, + 11, + 249, + 79, + 14, + 105 + ], + "ciphertext": [ + 107, + 230, + 27, + 23, + 183, + 247, + 212, + 148, + 167, + 205, + 242, + 112, + 86, + 47, + 55, + 186 + ], + "tag": [ + 94, + 112, + 42, + 56, + 50, + 63, + 225, + 22, + 11, + 120, + 13, + 23, + 173, + 173, + 62, + 150 + ] + }, + { + "key": [ + 163, + 89, + 185, + 88, + 75, + 238, + 193, + 137, + 82, + 127, + 136, + 66, + 221, + 166, + 182, + 212, + 198, + 165, + 219, + 47, + 136, + 150, + 53, + 113, + 95, + 163, + 188, + 215, + 150, + 124, + 10, + 113 + ], + "nonce": [ + 134, + 22, + 196, + 205, + 225, + 27, + 52, + 169, + 68, + 202, + 186, + 50 + ], + "aad": [ + 225, + 121, + 111, + 202, + 32, + 203, + 61, + 58, + 176, + 173, + 230, + 155, + 42, + 24, + 137, + 30 + ], + "plaintext": [ + 51, + 164, + 107, + 117, + 57, + 214, + 76, + 110, + 27, + 219, + 145, + 186, + 34, + 30, + 48, + 7 + ], + "ciphertext": [ + 176, + 211, + 22, + 233, + 95, + 63, + 51, + 144, + 186, + 16, + 208, + 39, + 73, + 101, + 198, + 43 + ], + "tag": [ + 174, + 174, + 220, + 248, + 160, + 18, + 204, + 50, + 239, + 37, + 166, + 39, + 144, + 233, + 51, + 76 + ] + }, + { + "key": [ + 140, + 131, + 35, + 142, + 123, + 59, + 88, + 39, + 130, + 0, + 181, + 73, + 64, + 215, + 121, + 208, + 160, + 117, + 6, + 115, + 170, + 176, + 191, + 47, + 88, + 8, + 221, + 21, + 220, + 26, + 140, + 73 + ], + "nonce": [ + 112, + 248, + 244, + 235, + 228, + 8, + 246, + 26, + 53, + 7, + 121, + 86 + ], + "aad": [ + 225, + 203, + 248, + 57, + 36, + 241, + 184, + 209, + 1, + 75, + 151, + 219, + 86, + 194, + 90, + 21 + ], + "plaintext": [ + 110, + 87, + 248, + 87, + 45, + 213, + 178, + 36, + 116, + 16, + 240, + 212, + 199, + 66, + 65, + 134 + ], + "ciphertext": [ + 74, + 17, + 172, + 185, + 97, + 18, + 81, + 223, + 1, + 247, + 159, + 22, + 248, + 32, + 31, + 251 + ], + "tag": [ + 151, + 50, + 190, + 74, + 208, + 86, + 149, + 134, + 117, + 61, + 144, + 250, + 187, + 6, + 246, + 44 + ] + }, + { + "key": [ + 254, + 33, + 145, + 155, + 179, + 32, + 175, + 135, + 68, + 201, + 232, + 98, + 181, + 183, + 207, + 139, + 129, + 173, + 58, + 209, + 251, + 14, + 125, + 125, + 113, + 10, + 104, + 141, + 62, + 237, + 21, + 75 + ], + "nonce": [ + 56, + 188, + 57, + 23, + 170, + 25, + 37, + 244, + 8, + 80, + 192, + 130 + ], + "aad": [ + 242, + 65, + 2, + 250, + 126, + 107, + 129, + 155, + 179, + 255, + 71, + 249, + 8, + 68, + 219, + 156 + ], + "plaintext": [ + 174, + 165, + 59, + 30, + 167, + 154, + 113, + 195, + 164, + 184, + 60, + 146, + 160, + 201, + 121, + 241 + ], + "ciphertext": [ + 47, + 184, + 182, + 151, + 191, + 143, + 122, + 46, + 234, + 37, + 254, + 112, + 42, + 58, + 224, + 169 + ], + "tag": [ + 91, + 231, + 126, + 130, + 119, + 55, + 173, + 124, + 79, + 121, + 224, + 227, + 67, + 254, + 1, + 13 + ] + }, + { + "key": [ + 73, + 158, + 138, + 63, + 57, + 172, + 74, + 188, + 98, + 221, + 78, + 26, + 97, + 51, + 4, + 46, + 116, + 120, + 89, + 114, + 182, + 181, + 1, + 191, + 175, + 254, + 252, + 139, + 178, + 159, + 211, + 18 + ], + "nonce": [ + 92, + 114, + 141, + 187, + 239, + 157, + 204, + 15, + 244, + 131, + 232, + 145 + ], + "aad": [ + 130, + 48, + 13, + 171, + 89, + 47, + 132, + 10, + 233, + 145, + 239, + 163, + 98, + 58, + 98, + 3 + ], + "plaintext": [ + 180, + 64, + 20, + 199, + 252, + 107, + 63, + 21, + 209, + 38, + 168, + 129, + 251, + 226, + 189, + 43 + ], + "ciphertext": [ + 87, + 143, + 229, + 225, + 174, + 247, + 97, + 159, + 57, + 44, + 2, + 124, + 131, + 138, + 35, + 158 + ], + "tag": [ + 73, + 253, + 199, + 36, + 240, + 94, + 181, + 110, + 169, + 227, + 253, + 20, + 182, + 26, + 213, + 103 + ] + }, + { + "key": [ + 39, + 117, + 211, + 231, + 168, + 252, + 102, + 91, + 185, + 165, + 158, + 220, + 34, + 235, + 19, + 106, + 221, + 25, + 72, + 36, + 237, + 143, + 42, + 219, + 68, + 145, + 119, + 64, + 76, + 115, + 151, + 22 + ], + "nonce": [ + 115, + 241, + 108, + 5, + 78, + 22, + 102, + 150, + 223, + 103, + 154, + 46 + ], + "aad": [ + 35, + 25, + 154, + 28, + 155, + 114, + 68, + 145, + 57, + 82, + 202, + 79, + 126, + 116, + 68, + 244 + ], + "plaintext": [ + 201, + 243, + 188, + 228, + 3, + 16, + 182, + 192, + 163, + 253, + 98, + 116, + 46, + 79, + 54, + 23 + ], + "ciphertext": [ + 114, + 200, + 92, + 16, + 117, + 98, + 102, + 208, + 10, + 154, + 67, + 64, + 178, + 203, + 49, + 55 + ], + "tag": [ + 88, + 129, + 228, + 86, + 91, + 66, + 57, + 78, + 98, + 213, + 218, + 240, + 209, + 235, + 197, + 147 + ] + }, + { + "key": [ + 66, + 90, + 52, + 28, + 103, + 230, + 216, + 115, + 135, + 15, + 84, + 226, + 204, + 90, + 41, + 132, + 199, + 52, + 232, + 23, + 41, + 192, + 219, + 170, + 238, + 224, + 80, + 48, + 159, + 28, + 230, + 116 + ], + "nonce": [ + 12, + 9, + 183, + 180, + 233, + 224, + 151, + 49, + 123, + 121, + 20, + 51 + ], + "aad": [ + 67, + 0, + 167, + 33, + 84, + 120, + 70, + 118, + 30, + 75, + 248, + 223, + 43, + 110, + 193, + 214 + ], + "plaintext": [ + 118, + 221, + 166, + 68, + 179, + 250, + 202, + 80, + 155, + 55, + 222, + 240, + 49, + 159, + 48, + 204 + ], + "ciphertext": [ + 29, + 216, + 13, + 170, + 15, + 201, + 228, + 126, + 67, + 137, + 124, + 100, + 166, + 102, + 63, + 94 + ], + "tag": [ + 93, + 105, + 179, + 77, + 140, + 59, + 18, + 247, + 131, + 250, + 174, + 167, + 233, + 54, + 133, + 219 + ] + }, + { + "key": [ + 221, + 92, + 72, + 152, + 138, + 110, + 159, + 159, + 96, + 190, + 128, + 27, + 165, + 192, + 144, + 242, + 36, + 161, + 181, + 61, + 102, + 1, + 236, + 88, + 88, + 234, + 183, + 183, + 120, + 74, + 141, + 94 + ], + "nonce": [ + 67, + 86, + 45, + 72, + 205, + 65, + 16, + 166, + 109, + 156, + 166, + 78 + ], + "aad": [ + 85, + 229, + 104, + 48, + 159, + 198, + 203, + 15, + 176, + 224, + 231, + 210, + 81, + 29, + 65, + 22 + ], + "plaintext": [ + 44, + 218, + 39, + 97, + 253, + 11, + 226, + 176, + 63, + 151, + 20, + 252, + 232, + 208, + 227, + 3 + ], + "ciphertext": [ + 242, + 207, + 182, + 245, + 68, + 110, + 122, + 161, + 114, + 173, + 252, + 214, + 107, + 146, + 169, + 141 + ], + "tag": [ + 224, + 153, + 198, + 77, + 41, + 102, + 231, + 128, + 206, + 125, + 46, + 170, + 233, + 127, + 71, + 216 + ] + }, + { + "key": [ + 43, + 218, + 217, + 195, + 229, + 222, + 110, + 78, + 16, + 27, + 127, + 22, + 231, + 39, + 198, + 144, + 219, + 149, + 234, + 207, + 75, + 12, + 203, + 222, + 199, + 170, + 182, + 251, + 159, + 200, + 4, + 134 + ], + "nonce": [ + 165, + 207, + 57, + 103, + 210, + 68, + 7, + 77, + 33, + 83, + 197, + 118 + ], + "aad": [ + 107, + 218, + 231, + 43, + 94, + 208, + 228, + 209, + 241, + 0, + 100, + 235, + 208, + 44, + 248, + 92 + ], + "plaintext": [ + 132, + 200, + 103, + 236, + 54, + 204, + 111, + 227, + 72, + 127, + 81, + 146, + 253, + 253, + 57, + 11 + ], + "ciphertext": [ + 83, + 200, + 250, + 67, + 124, + 27, + 95, + 169, + 26, + 187, + 214, + 80, + 139, + 56, + 120, + 206 + ], + "tag": [ + 120, + 89, + 89, + 61, + 18, + 115, + 36, + 190, + 139, + 156, + 241, + 212, + 62, + 173, + 77, + 130 + ] + }, + { + "key": [ + 1, + 233, + 42, + 253, + 181, + 217, + 86, + 190, + 18, + 211, + 139, + 9, + 37, + 41, + 102, + 197, + 114, + 141, + 38, + 243, + 199, + 46, + 84, + 187, + 98, + 187, + 197, + 90, + 229, + 144, + 231, + 22 + ], + "nonce": [ + 136, + 110, + 85, + 54, + 78, + 235, + 144, + 232, + 122, + 199, + 155, + 190 + ], + "aad": [ + 199, + 106, + 171, + 183, + 244, + 75, + 148, + 42, + 129, + 254, + 181, + 2, + 73, + 210, + 19, + 26 + ], + "plaintext": [ + 108, + 101, + 112, + 56, + 95, + 61, + 109, + 147, + 126, + 84, + 163, + 162, + 233, + 91, + 201, + 235 + ], + "ciphertext": [ + 66, + 59, + 116, + 154, + 80, + 127, + 67, + 123, + 67, + 17, + 20, + 150, + 33, + 128, + 211, + 82 + ], + "tag": [ + 84, + 216, + 89, + 50, + 10, + 73, + 40, + 19, + 104, + 41, + 125, + 167, + 212, + 227, + 115, + 38 + ] + }, + { + "key": [ + 70, + 146, + 19, + 25, + 33, + 117, + 152, + 203, + 100, + 37, + 111, + 228, + 154, + 188, + 161, + 241, + 138, + 157, + 29, + 188, + 163, + 96, + 248, + 99, + 10, + 251, + 92, + 97, + 55, + 203, + 66, + 181 + ], + "nonce": [ + 41, + 8, + 39, + 207, + 152, + 20, + 21, + 118, + 14, + 195, + 179, + 122 + ], + "aad": [ + 83, + 94, + 232, + 11, + 18, + 245, + 129, + 186, + 175, + 128, + 39, + 230, + 227, + 144, + 14, + 49 + ], + "plaintext": [ + 72, + 13, + 50, + 177, + 145, + 194, + 226, + 1, + 174, + 208, + 54, + 128, + 249, + 62, + 162, + 218 + ], + "ciphertext": [ + 137, + 172, + 228, + 247, + 53, + 131, + 251, + 26, + 194, + 96, + 222, + 169, + 155, + 84, + 5, + 94 + ], + "tag": [ + 123, + 139, + 131, + 88, + 54, + 60, + 23, + 90, + 102, + 230, + 251, + 72, + 209, + 188, + 34, + 34 + ] + }, + { + "key": [ + 225, + 140, + 217, + 176, + 27, + 89, + 188, + 13, + 225, + 80, + 46, + 251, + 116, + 195, + 100, + 41, + 151, + 254, + 125, + 251, + 141, + 128, + 200, + 167, + 60, + 175, + 254, + 119, + 38, + 128, + 125, + 51 + ], + "nonce": [ + 189, + 8, + 123, + 56, + 76, + 64, + 132, + 27, + 56, + 57, + 186, + 2 + ], + "aad": [ + 254, + 105, + 248, + 55, + 150, + 27, + 29, + 131, + 242, + 127, + 191, + 104, + 230, + 121, + 26, + 28 + ], + "plaintext": [ + 98, + 247, + 243, + 161, + 43, + 140, + 95, + 103, + 71, + 252, + 254, + 25, + 45, + 133, + 11, + 25 + ], + "ciphertext": [ + 186, + 207, + 204, + 246, + 57, + 116, + 36, + 233, + 108, + 175, + 118, + 30, + 113, + 221, + 62, + 58 + ], + "tag": [ + 156, + 154, + 91, + 101, + 66, + 15, + 131, + 231, + 102, + 199, + 192, + 81, + 104, + 14, + 142, + 88 + ] + }, + { + "key": [ + 104, + 238, + 70, + 59, + 49, + 83, + 217, + 160, + 66, + 229, + 227, + 104, + 93, + 239, + 111, + 144, + 247, + 101, + 154, + 32, + 52, + 65, + 222, + 51, + 127, + 185, + 72, + 49, + 203, + 234, + 233, + 178 + ], + "nonce": [ + 156, + 74, + 146, + 84, + 196, + 133, + 35, + 108, + 248, + 56, + 222, + 126 + ], + "aad": [ + 213, + 88, + 32, + 231, + 172, + 187, + 39, + 210, + 60, + 125, + 243, + 41, + 56, + 207, + 125, + 66 + ], + "plaintext": [ + 115, + 115, + 16, + 84, + 81, + 79, + 63, + 176, + 16, + 44, + 122, + 29, + 248, + 9, + 242, + 18 + ], + "ciphertext": [ + 19, + 183, + 130, + 60, + 172, + 55, + 244, + 14, + 184, + 17, + 227, + 201, + 102, + 209, + 106, + 103 + ], + "tag": [ + 118, + 40, + 140, + 51, + 166, + 111, + 246, + 69, + 30, + 44, + 236, + 108, + 75, + 164, + 147, + 94 + ] + }, + { + "key": [ + 100, + 189, + 89, + 77, + 175, + 39, + 158, + 49, + 114, + 249, + 170, + 113, + 59, + 53, + 183, + 252, + 232, + 244, + 48, + 131, + 121, + 43, + 199, + 209, + 241, + 9, + 25, + 19, + 31, + 64, + 10, + 123 + ], + "nonce": [ + 51, + 154, + 44, + 64, + 233, + 217, + 80, + 124, + 52, + 34, + 134, + 73 + ], + "aad": [ + 43, + 149, + 68, + 128, + 123, + 54, + 46, + 191, + 216, + 129, + 70, + 226, + 176, + 44, + 146, + 112 + ], + "plaintext": [ + 43, + 121, + 76, + 180, + 201, + 132, + 80, + 70, + 58, + 62, + 34, + 90, + 179, + 63, + 63, + 48 + ], + "ciphertext": [ + 67, + 77, + 112, + 59, + 141, + 16, + 105, + 173, + 128, + 54, + 40, + 139, + 124, + 45, + 26, + 230 + ], + "tag": [ + 125, + 49, + 227, + 151, + 192, + 201, + 67, + 203, + 177, + 108, + 251, + 149, + 57, + 166, + 161, + 125 + ] + }, + { + "key": [ + 131, + 104, + 141, + 235, + 74, + 248, + 0, + 127, + 155, + 113, + 59, + 71, + 207, + 166, + 199, + 62, + 53, + 234, + 122, + 58, + 164, + 236, + 219, + 65, + 77, + 222, + 208, + 59, + 247, + 160, + 253, + 58 + ], + "nonce": [ + 11, + 69, + 151, + 36, + 144, + 78, + 1, + 10, + 70, + 144, + 28, + 243 + ], + "aad": [ + 121, + 74, + 20, + 204, + 209, + 120, + 200, + 235, + 253, + 19, + 121, + 220, + 112, + 76, + 94, + 32, + 143, + 157, + 132, + 36 + ], + "plaintext": [ + 51, + 216, + 147, + 162, + 17, + 76, + 224, + 111, + 193, + 93, + 85, + 228, + 84, + 207, + 144, + 195 + ], + "ciphertext": [ + 204, + 102, + 190, + 228, + 35, + 227, + 252, + 212, + 192, + 134, + 87, + 21, + 233, + 88, + 102, + 150 + ], + "tag": [ + 15, + 178, + 145, + 189, + 61, + 186, + 148, + 161, + 223, + 216, + 178, + 134, + 207, + 185, + 122, + 197 + ] + }, + { + "key": [ + 1, + 63, + 84, + 154, + 249, + 236, + 194, + 238, + 2, + 89, + 213, + 252, + 35, + 17, + 5, + 156, + 182, + 241, + 15, + 108, + 214, + 206, + 211, + 181, + 67, + 186, + 190, + 116, + 56, + 168, + 130, + 81 + ], + "nonce": [ + 228, + 94, + 117, + 154, + 59, + 254, + 75, + 101, + 45, + 198, + 109, + 91 + ], + "aad": [ + 181, + 254, + 83, + 10, + 91, + 175, + 206, + 122, + 231, + 155, + 60, + 21, + 71, + 31, + 166, + 131, + 52, + 171, + 55, + 142 + ], + "plaintext": [ + 121, + 73, + 13, + 77, + 35, + 59, + 165, + 148, + 236, + 225, + 20, + 46, + 49, + 10, + 152, + 87 + ], + "ciphertext": [ + 97, + 148, + 67, + 3, + 78, + 68, + 55, + 184, + 147, + 164, + 90, + 76, + 137, + 250, + 216, + 81 + ], + "tag": [ + 109, + 168, + 169, + 145, + 182, + 144, + 255, + 106, + 68, + 32, + 135, + 163, + 86, + 248, + 233, + 227 + ] + }, + { + "key": [ + 75, + 40, + 21, + 197, + 49, + 210, + 252, + 234, + 179, + 3, + 236, + 139, + 202, + 115, + 154, + 151, + 171, + 202, + 147, + 115, + 183, + 212, + 21, + 173, + 157, + 108, + 111, + 169, + 120, + 37, + 24, + 204 + ], + "nonce": [ + 71, + 214, + 71, + 167, + 43, + 59, + 95, + 225, + 159, + 93, + 128, + 247 + ], + "aad": [ + 32, + 253, + 121, + 189, + 14, + 229, + 56, + 244, + 43, + 114, + 100, + 165, + 208, + 152, + 175, + 154, + 48, + 149, + 155, + 245 + ], + "plaintext": [ + 211, + 246, + 166, + 69, + 119, + 158, + 7, + 81, + 123, + 208, + 104, + 136, + 114, + 224, + 164, + 155 + ], + "ciphertext": [ + 0, + 190, + 59, + 41, + 88, + 153, + 196, + 85, + 17, + 10, + 10, + 232, + 51, + 20, + 12, + 77 + ], + "tag": [ + 208, + 84, + 227, + 153, + 124, + 0, + 133, + 232, + 112, + 85, + 183, + 152, + 41, + 236, + 54, + 41 + ] + }, + { + "key": [ + 37, + 3, + 185, + 9, + 165, + 105, + 246, + 24, + 247, + 235, + 24, + 110, + 76, + 75, + 129, + 219, + 254, + 151, + 76, + 85, + 62, + 42, + 22, + 162, + 154, + 234, + 104, + 70, + 41, + 62, + 26, + 81 + ], + "nonce": [ + 228, + 250, + 61, + 193, + 49, + 169, + 16, + 199, + 95, + 97, + 163, + 139 + ], + "aad": [ + 248, + 14, + 223, + 155, + 81, + 248, + 253, + 102, + 245, + 124, + 233, + 175, + 89, + 103, + 236, + 2, + 130, + 69, + 235, + 110 + ], + "plaintext": [ + 24, + 141, + 84, + 47, + 138, + 129, + 86, + 149, + 196, + 140, + 58, + 136, + 33, + 88, + 149, + 140 + ], + "ciphertext": [ + 77, + 57, + 181, + 73, + 76, + 161, + 43, + 119, + 0, + 153, + 168, + 235, + 12, + 23, + 138, + 202 + ], + "tag": [ + 173, + 218, + 84, + 173, + 12, + 127, + 132, + 140, + 28, + 114, + 117, + 132, + 6, + 180, + 147, + 85 + ] + }, + { + "key": [ + 108, + 143, + 52, + 241, + 69, + 105, + 246, + 37, + 170, + 215, + 178, + 50, + 245, + 159, + 168, + 177, + 135, + 171, + 36, + 250, + 220, + 219, + 175, + 125, + 142, + 180, + 93, + 168, + 249, + 20, + 230, + 115 + ], + "nonce": [ + 110, + 47, + 136, + 109, + 217, + 123, + 224, + 228, + 197, + 189, + 72, + 139 + ], + "aad": [ + 119, + 46, + 194, + 62, + 73, + 219, + 225, + 217, + 35, + 177, + 1, + 143, + 194, + 190, + 244, + 181, + 121, + 228, + 98, + 65 + ], + "plaintext": [ + 172, + 138, + 167, + 28, + 251, + 241, + 233, + 104, + 239, + 85, + 21, + 83, + 21, + 118, + 227, + 20 + ], + "ciphertext": [ + 203, + 12, + 231, + 3, + 69, + 233, + 80, + 180, + 41, + 231, + 16, + 196, + 125, + 156, + 141, + 155 + ], + "tag": [ + 157, + 206, + 234, + 152, + 196, + 56, + 177, + 217, + 193, + 84, + 229, + 56, + 97, + 128, + 150, + 109 + ] + }, + { + "key": [ + 24, + 47, + 229, + 96, + 97, + 78, + 28, + 106, + 223, + 209, + 86, + 106, + 196, + 72, + 86, + 223, + 114, + 61, + 203, + 126, + 23, + 26, + 124, + 87, + 150, + 182, + 211, + 248, + 62, + 243, + 210, + 51 + ], + "nonce": [ + 132, + 132, + 171, + 202, + 104, + 119, + 168, + 98, + 43, + 253, + 46, + 60 + ], + "aad": [ + 38, + 24, + 192, + 247, + 254, + 151, + 119, + 42, + 12, + 151, + 99, + 140, + 202, + 35, + 138, + 150, + 121, + 135, + 197, + 229 + ], + "plaintext": [ + 146, + 202, + 70, + 180, + 15, + 44, + 117, + 117, + 90, + 40, + 148, + 58, + 104, + 168, + 216, + 28 + ], + "ciphertext": [ + 237, + 25, + 65, + 179, + 48, + 244, + 39, + 93, + 5, + 137, + 159, + 134, + 119, + 215, + 54, + 55 + ], + "tag": [ + 63, + 233, + 63, + 31, + 95, + 250, + 72, + 68, + 150, + 61, + 225, + 220, + 150, + 77, + 25, + 150 + ] + }, + { + "key": [ + 101, + 162, + 144, + 178, + 250, + 190, + 124, + 213, + 251, + 47, + 109, + 98, + 126, + 159, + 31, + 121, + 194, + 199, + 20, + 191, + 251, + 79, + 184, + 110, + 157, + 243, + 229, + 234, + 178, + 131, + 32, + 237 + ], + "nonce": [ + 90, + 94, + 212, + 213, + 89, + 42, + 24, + 159, + 7, + 55, + 207, + 71 + ], + "aad": [ + 173, + 28, + 127, + 122, + 127, + 183, + 248, + 254, + 244, + 129, + 156, + 29, + 209, + 166, + 126, + 0, + 124, + 153, + 168, + 123 + ], + "plaintext": [ + 102, + 45, + 218, + 15, + 156, + 143, + 146, + 188, + 144, + 110, + 144, + 40, + 129, + 0, + 80, + 28 + ], + "ciphertext": [ + 142, + 183, + 203, + 95, + 4, + 24, + 218, + 67, + 247, + 224, + 81, + 197, + 136, + 119, + 97, + 134 + ], + "tag": [ + 43, + 21, + 57, + 158, + 226, + 54, + 144, + 187, + 245, + 37, + 47, + 178, + 106, + 1, + 174, + 52 + ] + }, + { + "key": [ + 123, + 114, + 13, + 49, + 205, + 98, + 150, + 109, + 212, + 208, + 2, + 201, + 234, + 65, + 188, + 252, + 65, + 158, + 109, + 40, + 93, + 250, + 176, + 2, + 59, + 162, + 27, + 52, + 231, + 84, + 203, + 47 + ], + "nonce": [ + 225, + 251, + 31, + 146, + 41, + 180, + 81, + 183, + 47, + 137, + 195, + 51 + ], + "aad": [ + 127, + 218, + 228, + 45, + 12, + 246, + 161, + 56, + 115, + 211, + 9, + 44, + 65, + 221, + 58, + 25, + 169, + 234, + 144, + 249 + ], + "plaintext": [ + 26, + 162, + 148, + 142, + 216, + 4, + 242, + 78, + 93, + 120, + 59, + 27, + 201, + 89, + 224, + 134 + ], + "ciphertext": [ + 134, + 49, + 211, + 198, + 182, + 100, + 120, + 102, + 184, + 104, + 66, + 27, + 106, + 58, + 84, + 138 + ], + "tag": [ + 163, + 31, + 235, + 190, + 22, + 157, + 141, + 111, + 57, + 26, + 94, + 96, + 239, + 98, + 67, + 160 + ] + }, + { + "key": [ + 162, + 174, + 200, + 243, + 67, + 138, + 180, + 214, + 217, + 174, + 86, + 106, + 44, + 249, + 16, + 26, + 211, + 163, + 204, + 32, + 248, + 54, + 116, + 194, + 226, + 8, + 232, + 202, + 90, + 186, + 194, + 187 + ], + "nonce": [ + 129, + 92, + 2, + 6, + 134, + 197, + 42, + 229, + 221, + 200, + 22, + 128 + ], + "aad": [ + 134, + 18, + 12, + 227, + 170, + 129, + 68, + 90, + 134, + 217, + 113, + 253, + 183, + 179, + 179, + 60, + 7, + 178, + 91, + 214 + ], + "plaintext": [ + 165, + 204, + 248, + 180, + 234, + 194, + 47, + 14, + 26, + 172, + 16, + 184, + 214, + 44, + 220, + 105 + ], + "ciphertext": [ + 54, + 76, + 154, + 222, + 112, + 151, + 231, + 95, + 153, + 24, + 126, + 85, + 113, + 236, + 46, + 82 + ], + "tag": [ + 100, + 195, + 34, + 174, + 122, + 141, + 191, + 61, + 36, + 7, + 177, + 38, + 1, + 229, + 9, + 66 + ] + }, + { + "key": [ + 229, + 16, + 76, + 252, + 191, + 163, + 14, + 86, + 145, + 93, + 156, + 247, + 158, + 252, + 240, + 100, + 161, + 212, + 206, + 25, + 25, + 184, + 194, + 13, + 228, + 126, + 171, + 12, + 16, + 109, + 103, + 193 + ], + "nonce": [ + 209, + 165, + 236, + 121, + 53, + 151, + 116, + 92, + 122, + 49, + 182, + 5 + ], + "aad": [ + 153, + 49, + 103, + 132, + 48, + 255, + 58, + 167, + 101, + 184, + 113, + 183, + 3, + 223, + 204, + 67, + 251, + 27, + 133, + 148 + ], + "plaintext": [ + 123, + 107, + 48, + 51, + 129, + 68, + 31, + 63, + 223, + 154, + 12, + 247, + 158, + 226, + 233, + 224 + ], + "ciphertext": [ + 66, + 93, + 72, + 167, + 96, + 1, + 190, + 217, + 218, + 39, + 6, + 54, + 190, + 31, + 119, + 11 + ], + "tag": [ + 118, + 255, + 67, + 161, + 87, + 166, + 116, + 130, + 80, + 163, + 253, + 238, + 116, + 70, + 237, + 34 + ] + }, + { + "key": [ + 244, + 97, + 209, + 183, + 90, + 114, + 217, + 66, + 170, + 9, + 99, + 132, + 220, + 32, + 207, + 133, + 20, + 169, + 173, + 154, + 151, + 32, + 102, + 10, + 221, + 63, + 49, + 130, + 132, + 202, + 48, + 20 + ], + "nonce": [ + 208, + 73, + 95, + 37, + 135, + 78, + 87, + 20, + 161, + 20, + 158, + 148 + ], + "aad": [ + 17, + 51, + 243, + 114, + 227, + 219, + 34, + 69, + 110, + 126, + 169, + 47, + 41, + 223, + 247, + 241, + 217, + 40, + 100, + 211 + ], + "plaintext": [ + 217, + 228, + 185, + 103, + 253, + 202, + 140, + 139, + 174, + 131, + 138, + 93, + 169, + 93, + 124, + 206 + ], + "ciphertext": [ + 29, + 247, + 17, + 230, + 251, + 203, + 162, + 43, + 5, + 100, + 198, + 227, + 96, + 81, + 163, + 247 + ], + "tag": [ + 240, + 86, + 59, + 116, + 148, + 213, + 21, + 146, + 137, + 182, + 68, + 175, + 196, + 232, + 227, + 151 + ] + }, + { + "key": [ + 169, + 169, + 142, + 245, + 7, + 108, + 235, + 69, + 196, + 182, + 10, + 147, + 174, + 186, + 16, + 37, + 7, + 249, + 119, + 188, + 155, + 112, + 222, + 209, + 173, + 125, + 66, + 33, + 8, + 205, + 170, + 101 + ], + "nonce": [ + 84, + 161, + 188, + 103, + 227, + 168, + 163, + 228, + 77, + 238, + 194, + 50 + ], + "aad": [ + 16, + 207, + 239, + 5, + 226, + 205, + 30, + 221, + 48, + 219, + 92, + 2, + 139, + 217, + 54, + 160, + 61, + 240, + 59, + 220 + ], + "plaintext": [ + 237, + 233, + 61, + 209, + 234, + 167, + 201, + 133, + 154, + 15, + 112, + 159, + 134, + 164, + 135, + 118 + ], + "ciphertext": [ + 61, + 59, + 97, + 245, + 83, + 171, + 89, + 169, + 240, + 147, + 202, + 196, + 90, + 250, + 90, + 192 + ], + "tag": [ + 120, + 20, + 207, + 200, + 115, + 179, + 57, + 141, + 153, + 125, + 139, + 179, + 142, + 173, + 88, + 239 + ] + }, + { + "key": [ + 217, + 225, + 124, + 152, + 130, + 96, + 13, + 212, + 210, + 237, + 190, + 174, + 154, + 34, + 77, + 133, + 136, + 255, + 90, + 162, + 16, + 189, + 144, + 45, + 16, + 128, + 166, + 145, + 16, + 16, + 197, + 197 + ], + "nonce": [ + 129, + 127, + 53, + 1, + 233, + 119, + 164, + 90, + 158, + 17, + 15, + 212 + ], + "aad": [ + 210, + 22, + 40, + 72, + 17, + 50, + 27, + 117, + 145, + 82, + 143, + 10, + 245, + 163, + 242, + 118, + 132, + 41, + 228, + 232 + ], + "plaintext": [ + 215, + 77, + 150, + 142, + 168, + 1, + 33, + 174, + 160, + 215, + 162, + 164, + 92, + 213, + 56, + 140 + ], + "ciphertext": [ + 21, + 135, + 200, + 176, + 14, + 44, + 25, + 127, + 50, + 162, + 16, + 25, + 254, + 238, + 233, + 154 + ], + "tag": [ + 99, + 234, + 67, + 192, + 61, + 0, + 248, + 174, + 87, + 36, + 88, + 156, + 182, + 246, + 68, + 128 + ] + }, + { + "key": [ + 236, + 37, + 27, + 69, + 203, + 112, + 37, + 152, + 70, + 219, + 83, + 10, + 255, + 17, + 182, + 59, + 224, + 10, + 149, + 24, + 39, + 2, + 14, + 157, + 116, + 102, + 89, + 190, + 242, + 177, + 253, + 111 + ], + "nonce": [ + 228, + 22, + 82, + 229, + 123, + 98, + 74, + 189, + 132, + 254, + 23, + 58 + ], + "aad": [ + 146, + 221, + 43, + 0, + 185, + 220, + 108, + 97, + 48, + 17, + 229, + 222, + 228, + 119, + 225, + 10, + 110, + 82, + 56, + 156 + ], + "plaintext": [ + 117, + 2, + 63, + 81, + 186, + 129, + 182, + 128, + 180, + 78, + 163, + 82, + 196, + 63, + 112, + 12 + ], + "ciphertext": [ + 41, + 39, + 69, + 153, + 169, + 93, + 99, + 240, + 84, + 174, + 12, + 155, + 157, + 243, + 230, + 141 + ], + "tag": [ + 235, + 25, + 152, + 59, + 159, + 144, + 160, + 233, + 245, + 86, + 33, + 61, + 124, + 77, + 240, + 249 + ] + }, + { + "key": [ + 97, + 247, + 31, + 219, + 226, + 159, + 86, + 187, + 15, + 223, + 138, + 157, + 168, + 12, + 239, + 105, + 92, + 150, + 154, + 39, + 118, + 168, + 142, + 98, + 203, + 61, + 57, + 252, + 164, + 123, + 24, + 227 + ], + "nonce": [ + 119, + 241, + 215, + 90, + 176, + 227, + 160, + 237, + 155, + 242, + 185, + 129 + ], + "aad": [ + 200, + 130, + 105, + 24, + 17, + 211, + 222, + 108, + 146, + 125, + 28, + 159, + 42, + 15, + 21, + 247, + 130, + 213, + 92, + 33 + ], + "plaintext": [ + 17, + 10, + 92, + 9, + 112, + 52, + 130, + 239, + 19, + 67, + 57, + 109, + 12, + 56, + 82, + 211 + ], + "ciphertext": [ + 126, + 157, + 170, + 73, + 131, + 40, + 63, + 172, + 210, + 154, + 147, + 3, + 126, + 183, + 11, + 176 + ], + "tag": [ + 36, + 73, + 48, + 150, + 89, + 19, + 235, + 224, + 250, + 122, + 14, + 181, + 71, + 177, + 89, + 251 + ] + }, + { + "key": [ + 228, + 254, + 211, + 57, + 199, + 176, + 205, + 38, + 115, + 5, + 209, + 26, + 176, + 213, + 195, + 39, + 54, + 50, + 232, + 135, + 45, + 53, + 189, + 195, + 103, + 161, + 54, + 52, + 56, + 35, + 154, + 53 + ], + "nonce": [ + 3, + 101, + 136, + 44, + 247, + 84, + 50, + 207, + 210, + 60, + 189, + 66 + ], + "aad": [ + 138, + 151, + 210, + 175, + 93, + 65, + 22, + 10, + 194, + 255, + 125, + 216, + 186, + 9, + 142, + 122, + 164, + 214, + 24, + 240, + 244, + 85, + 149, + 125, + 106, + 109, + 8, + 1, + 121, + 103, + 71, + 186, + 87, + 195, + 45, + 251, + 170, + 175, + 21, + 23, + 101, + 40, + 254, + 58, + 14, + 69, + 80, + 201 + ], + "plaintext": [ + 255, + 243, + 154, + 8, + 125, + 227, + 154, + 3, + 145, + 159, + 189, + 47, + 47, + 165, + 245, + 19 + ], + "ciphertext": [ + 141, + 158, + 104, + 240, + 63, + 126, + 95, + 74, + 15, + 250, + 167, + 101, + 13, + 2, + 109, + 8 + ], + "tag": [ + 53, + 84, + 84, + 44, + 71, + 140, + 6, + 53, + 40, + 90, + 97, + 209, + 181, + 31, + 106, + 250 + ] + }, + { + "key": [ + 189, + 147, + 199, + 191, + 200, + 80, + 179, + 60, + 134, + 72, + 78, + 4, + 133, + 158, + 211, + 116, + 190, + 174, + 233, + 214, + 19, + 189, + 202, + 111, + 7, + 45, + 29, + 24, + 42, + 238, + 189, + 4 + ], + "nonce": [ + 100, + 20, + 199, + 116, + 158, + 255, + 185, + 175, + 126, + 92, + 71, + 98 + ], + "aad": [ + 118, + 244, + 61, + 86, + 100, + 199, + 172, + 27, + 77, + 228, + 63, + 46, + 44, + 75, + 199, + 31, + 105, + 24, + 224, + 118, + 47, + 64, + 229, + 221, + 85, + 151, + 239, + 79, + 242, + 21, + 133, + 90, + 79, + 210, + 109, + 62, + 166, + 204, + 189, + 78, + 16, + 120, + 153, + 72, + 250, + 105, + 36, + 51 + ], + "plaintext": [ + 182, + 222, + 22, + 153, + 147, + 31, + 34, + 82, + 239, + 201, + 141, + 73, + 29, + 34, + 238, + 18 + ], + "ciphertext": [ + 166, + 199, + 229, + 47, + 32, + 24, + 184, + 35, + 80, + 110, + 72, + 6, + 79, + 254, + 110, + 228 + ], + "tag": [ + 23, + 94, + 101, + 60, + 144, + 54, + 246, + 104, + 53, + 241, + 12, + 241, + 200, + 45, + 23, + 65 + ] + }, + { + "key": [ + 223, + 1, + 37, + 168, + 38, + 199, + 254, + 73, + 36, + 61, + 137, + 203, + 221, + 117, + 98, + 170, + 253, + 33, + 3, + 250, + 39, + 131, + 207, + 144, + 25, + 118, + 181, + 245, + 212, + 129, + 205, + 203 + ], + "nonce": [ + 246, + 60, + 20, + 97, + 178, + 150, + 73, + 41, + 208, + 53, + 217, + 191 + ], + "aad": [ + 11, + 246, + 2, + 236, + 71, + 89, + 62, + 68, + 172, + 27, + 136, + 36, + 68, + 85, + 250, + 4, + 53, + 158, + 51, + 128, + 87, + 176, + 160, + 186, + 5, + 124, + 181, + 6, + 213, + 70, + 212, + 214, + 216, + 83, + 134, + 64, + 254, + 125, + 211, + 213, + 134, + 75, + 211, + 59, + 90, + 51, + 215, + 104 + ], + "plaintext": [ + 204, + 39, + 255, + 104, + 249, + 129, + 228, + 214, + 251, + 25, + 24, + 66, + 124, + 61, + 107, + 158 + ], + "ciphertext": [ + 184, + 250, + 21, + 10, + 249, + 48, + 120, + 87, + 74, + 199, + 196, + 97, + 95, + 136, + 100, + 125 + ], + "tag": [ + 69, + 132, + 85, + 58, + 195, + 204, + 223, + 139, + 14, + 250, + 229, + 23, + 101, + 45, + 58, + 24 + ] + }, + { + "key": [ + 211, + 62, + 163, + 32, + 206, + 192, + 228, + 61, + 252, + 30, + 61, + 29, + 140, + 204, + 162, + 221, + 126, + 48, + 173, + 62, + 161, + 138, + 215, + 20, + 28, + 200, + 54, + 69, + 209, + 135, + 113, + 174 + ], + "nonce": [ + 84, + 0, + 9, + 243, + 33, + 244, + 29, + 0, + 32, + 46, + 71, + 59 + ], + "aad": [ + 164, + 17, + 98, + 225, + 254, + 135, + 90, + 129, + 251, + 181, + 102, + 127, + 115, + 197, + 212, + 203, + 187, + 156, + 57, + 86, + 0, + 47, + 120, + 103, + 4, + 126, + 222, + 193, + 91, + 220, + 172, + 18, + 6, + 229, + 25, + 238, + 156, + 35, + 140, + 55, + 26, + 56, + 164, + 133, + 199, + 16, + 218, + 96 + ], + "plaintext": [ + 229, + 108, + 221, + 82, + 45, + 82, + 109, + 141, + 12, + 209, + 129, + 49, + 161, + 158, + 228, + 253 + ], + "ciphertext": [ + 139, + 98, + 75, + 111, + 84, + 131, + 244, + 47, + 54, + 200, + 93, + 199, + 207, + 62, + 150, + 9 + ], + "tag": [ + 38, + 81, + 233, + 120, + 217, + 234, + 166, + 197, + 244, + 219, + 82, + 57, + 26, + 201, + 188, + 124 + ] + }, + { + "key": [ + 127, + 53, + 245, + 151, + 155, + 35, + 50, + 30, + 100, + 73, + 240, + 245, + 239, + 153, + 242, + 231, + 183, + 150, + 213, + 45, + 86, + 12, + 199, + 122, + 171, + 251, + 98, + 29, + 191, + 58, + 101, + 48 + ], + "nonce": [ + 207, + 15, + 111, + 62, + 237, + 76, + 243, + 116, + 218, + 113, + 76, + 119 + ], + "aad": [ + 166, + 118, + 211, + 93, + 147, + 225, + 43, + 254, + 6, + 3, + 246, + 174, + 242, + 195, + 221, + 137, + 42, + 155, + 26, + 210, + 45, + 71, + 108, + 53, + 9, + 211, + 19, + 37, + 109, + 78, + 152, + 228, + 221, + 164, + 228, + 110, + 147, + 181, + 76, + 245, + 156, + 43, + 144, + 96, + 138, + 143, + 179, + 173 + ], + "plaintext": [ + 78, + 159, + 83, + 175, + 253, + 181, + 177, + 233, + 27, + 244, + 35, + 210, + 156, + 84, + 64, + 26 + ], + "ciphertext": [ + 23, + 20, + 213, + 94, + 248, + 61, + 242, + 146, + 126, + 233, + 95, + 242, + 47, + 29, + 144, + 230 + ], + "tag": [ + 73, + 98, + 169, + 29, + 16, + 113, + 221, + 44, + 5, + 147, + 73, + 104, + 210, + 30, + 180, + 60 + ] + }, + { + "key": [ + 6, + 236, + 193, + 52, + 153, + 53, + 6, + 207, + 83, + 155, + 30, + 121, + 122, + 81, + 159, + 225, + 217, + 243, + 67, + 33, + 254, + 106, + 11, + 5, + 241, + 147, + 98, + 133, + 195, + 92, + 147, + 164 + ], + "nonce": [ + 242, + 25, + 8, + 97, + 209, + 20, + 11, + 208, + 128, + 215, + 153, + 6 + ], + "aad": [ + 160, + 79, + 39, + 35, + 194, + 82, + 17, + 129, + 67, + 122, + 214, + 63, + 121, + 16, + 72, + 29, + 93, + 233, + 143, + 62, + 37, + 97, + 206, + 195, + 161, + 119, + 189, + 188, + 181, + 4, + 134, + 25, + 115, + 136, + 82, + 224, + 251, + 33, + 42, + 60, + 170, + 116, + 26, + 53, + 62, + 78, + 137, + 168 + ], + "plaintext": [ + 81, + 156, + 31, + 196, + 90, + 98, + 142, + 193, + 108, + 81, + 84, + 39, + 121, + 103, + 17, + 247 + ], + "ciphertext": [ + 179, + 108, + 121, + 50, + 36, + 206, + 59, + 177, + 181, + 65, + 68, + 57, + 143, + 189, + 237, + 182 + ], + "tag": [ + 0, + 48, + 230, + 232, + 79, + 111, + 142, + 180, + 116, + 206, + 142, + 7, + 28, + 41, + 83, + 221 + ] + }, + { + "key": [ + 115, + 79, + 168, + 180, + 35, + 185, + 30, + 14, + 204, + 204, + 127, + 85, + 68, + 128, + 238, + 245, + 122, + 130, + 66, + 58, + 159, + 146, + 178, + 141, + 70, + 67, + 32, + 251, + 164, + 5, + 167, + 28 + ], + "nonce": [ + 166, + 181, + 199, + 139, + 181, + 121, + 31, + 77, + 18, + 19, + 144, + 206 + ], + "aad": [ + 156, + 226, + 95, + 249, + 181, + 93, + 250, + 4, + 228, + 39, + 25, + 153, + 164, + 124, + 186, + 138, + 248, + 232, + 58, + 57, + 11, + 9, + 13, + 28, + 67, + 6, + 180, + 12, + 232, + 136, + 38, + 36, + 182, + 98, + 255, + 88, + 103, + 137, + 99, + 150, + 120, + 146, + 149, + 193, + 158, + 200, + 13, + 7 + ], + "plaintext": [ + 180, + 150, + 169, + 155, + 57, + 224, + 233, + 75, + 181, + 130, + 156, + 252, + 61, + 123, + 56, + 86 + ], + "ciphertext": [ + 144, + 64, + 129, + 164, + 4, + 132, + 187, + 100, + 84, + 252, + 82, + 203, + 102, + 116, + 231, + 55 + ], + "tag": [ + 106, + 7, + 135, + 207, + 57, + 33, + 167, + 28, + 53, + 181, + 5, + 73, + 84, + 82, + 120, + 35 + ] + }, + { + "key": [ + 209, + 6, + 40, + 11, + 132, + 242, + 91, + 41, + 79, + 113, + 194, + 97, + 246, + 106, + 101, + 194, + 239, + 217, + 104, + 14, + 25, + 245, + 3, + 22, + 210, + 55, + 151, + 80, + 82, + 121, + 99, + 146 + ], + "nonce": [ + 207, + 198, + 170, + 42, + 235, + 164, + 104, + 198, + 107, + 244, + 85, + 63 + ], + "aad": [ + 1, + 42, + 67, + 249, + 144, + 58, + 56, + 8, + 191, + 52, + 253, + 111, + 119, + 216, + 49, + 217, + 21, + 66, + 5, + 222, + 213, + 137, + 150, + 76, + 174, + 96, + 210, + 228, + 156, + 133, + 107, + 122, + 65, + 0, + 165, + 92, + 140, + 208, + 47, + 94, + 71, + 111, + 98, + 233, + 136, + 220, + 189, + 43 + ], + "plaintext": [ + 87, + 233, + 55, + 248, + 185, + 184, + 20, + 233, + 101, + 187, + 86, + 159, + 207, + 99, + 170, + 172 + ], + "ciphertext": [ + 200, + 53, + 245, + 212, + 253, + 48, + 254, + 155, + 46, + 219, + 74, + 255, + 36, + 128, + 60, + 96 + ], + "tag": [ + 232, + 132, + 38, + 187, + 70, + 25, + 128, + 127, + 24, + 169, + 204, + 152, + 57, + 117, + 71, + 119 + ] + }, + { + "key": [ + 129, + 235, + 99, + 188, + 71, + 171, + 163, + 19, + 217, + 100, + 165, + 51, + 92, + 251, + 3, + 144, + 81, + 82, + 11, + 49, + 18, + 250, + 84, + 202, + 179, + 104, + 229, + 36, + 57, + 71, + 212, + 80 + ], + "nonce": [ + 24, + 204, + 93, + 216, + 117, + 117, + 63, + 245, + 28, + 198, + 244, + 65 + ], + "aad": [ + 36, + 247, + 102, + 197, + 103, + 119, + 49, + 36, + 148, + 36, + 90, + 78, + 108, + 125, + 190, + 187, + 174, + 64, + 38, + 224, + 144, + 126, + 173, + 188, + 32, + 164, + 136, + 152, + 38, + 120, + 22, + 29, + 231, + 185, + 36, + 71, + 60, + 10, + 129, + 238, + 89, + 160, + 250, + 105, + 5, + 149, + 43, + 51 + ], + "plaintext": [ + 69, + 245, + 19, + 153, + 223, + 246, + 160, + 220, + 212, + 63, + 53, + 37, + 102, + 22, + 214, + 190 + ], + "ciphertext": [ + 162, + 252, + 123, + 7, + 132, + 236, + 66, + 51, + 20, + 47, + 156, + 222, + 18, + 171, + 158, + 152 + ], + "tag": [ + 78, + 96, + 184, + 86, + 28, + 172, + 254, + 113, + 51, + 116, + 12, + 210, + 189, + 222, + 250, + 160 + ] + }, + { + "key": [ + 10, + 153, + 120, + 99, + 120, + 106, + 78, + 151, + 51, + 34, + 36, + 237, + 72, + 79, + 252, + 165, + 8, + 177, + 102, + 240, + 96, + 54, + 135, + 32, + 13, + 153, + 253, + 106, + 204, + 212, + 93, + 131 + ], + "nonce": [ + 122, + 154, + 202, + 189, + 75, + 141, + 62, + 16, + 54, + 41, + 58, + 7 + ], + "aad": [ + 82, + 95, + 197, + 172, + 127, + 233, + 60, + 24, + 58, + 62, + 247, + 199, + 94, + 63, + 189, + 82, + 220, + 233, + 86, + 133, + 90, + 255, + 56, + 89, + 102, + 244, + 215, + 153, + 102, + 189, + 179, + 236, + 32, + 25, + 196, + 102, + 88, + 77, + 33, + 191, + 238, + 116, + 81, + 26, + 119, + 216, + 42, + 219 + ], + "plaintext": [ + 157, + 44, + 159, + 243, + 159, + 87, + 201, + 110, + 204, + 226, + 135, + 198, + 140, + 92, + 214, + 235 + ], + "ciphertext": [ + 35, + 132, + 65, + 198, + 91, + 42, + 28, + 65, + 179, + 2, + 218, + 15, + 82, + 212, + 7, + 112 + ], + "tag": [ + 195, + 81, + 217, + 58, + 185, + 73, + 28, + 223, + 183, + 250, + 21, + 231, + 162, + 81, + 222, + 34 + ] + }, + { + "key": [ + 172, + 191, + 235, + 124, + 89, + 91, + 112, + 73, + 96, + 193, + 9, + 126, + 147, + 211, + 144, + 101, + 52, + 194, + 52, + 68, + 200, + 172, + 193, + 248, + 233, + 105, + 206, + 108, + 63, + 232, + 164, + 107 + ], + "nonce": [ + 40, + 146, + 46, + 202, + 195, + 1, + 56, + 6, + 193, + 22, + 96, + 230 + ], + "aad": [ + 177, + 254, + 136, + 97, + 7, + 1, + 62, + 189, + 235, + 25, + 49, + 90, + 157, + 9, + 110, + 216, + 24, + 3, + 149, + 26, + 80, + 143, + 86, + 246, + 130, + 2, + 167, + 223, + 0, + 190, + 186, + 224, + 116, + 45, + 209, + 18, + 140, + 32, + 9, + 82, + 160, + 73, + 239, + 12, + 215, + 207, + 228, + 230 + ], + "plaintext": [ + 224, + 216, + 197, + 45, + 96, + 198, + 237, + 105, + 128, + 171, + 212, + 52, + 143, + 63, + 150, + 241 + ], + "ciphertext": [ + 86, + 254, + 28, + 242, + 193, + 209, + 147, + 185, + 179, + 59, + 173, + 191, + 132, + 111, + 82, + 204 + ], + "tag": [ + 28, + 180, + 193, + 79, + 80, + 165, + 74, + 100, + 129, + 63, + 252, + 129, + 15, + 49, + 249, + 248 + ] + }, + { + "key": [ + 246, + 231, + 104, + 71, + 92, + 51, + 38, + 149, + 150, + 218, + 31, + 90, + 90, + 56, + 84, + 122, + 136, + 80, + 6, + 190, + 187, + 145, + 52, + 226, + 18, + 116, + 216, + 69, + 110, + 159, + 85, + 41 + ], + "nonce": [ + 53, + 121, + 229, + 172, + 81, + 209, + 241, + 184, + 46, + 163, + 82, + 202 + ], + "aad": [ + 105, + 41, + 182, + 5, + 59, + 161, + 72, + 48, + 67, + 102, + 22, + 79, + 121, + 177, + 185, + 245, + 146, + 201, + 203, + 155, + 206, + 101, + 9, + 76, + 236, + 92, + 184, + 176, + 252, + 99, + 226, + 13, + 134, + 177, + 124, + 139, + 245, + 167, + 176, + 137, + 166, + 60, + 94, + 172, + 24, + 36, + 238, + 147 + ], + "plaintext": [ + 10, + 164, + 129, + 248, + 86, + 248, + 185, + 101, + 71, + 103, + 46, + 90, + 229, + 55, + 15, + 158 + ], + "ciphertext": [ + 178, + 244, + 237, + 245, + 240, + 176, + 191, + 197, + 144, + 254, + 173, + 98, + 57, + 176, + 242, + 251 + ], + "tag": [ + 37, + 64, + 206, + 181, + 239, + 36, + 124, + 149, + 214, + 61, + 248, + 76, + 70, + 70, + 133, + 51 + ] + }, + { + "key": [ + 44, + 167, + 97, + 18, + 48, + 11, + 237, + 101, + 184, + 123, + 166, + 236, + 136, + 124, + 213, + 20, + 244, + 99, + 60, + 28, + 150, + 86, + 95, + 236, + 142, + 62, + 105, + 174, + 43, + 168, + 132, + 1 + ], + "nonce": [ + 150, + 72, + 100, + 81, + 10, + 140, + 149, + 125, + 207, + 185, + 125, + 47 + ], + "aad": [ + 90, + 235, + 223, + 209, + 83, + 161, + 135, + 99, + 243, + 110, + 204, + 158, + 142, + 154, + 1, + 203, + 123, + 63, + 33, + 228, + 53, + 179, + 91, + 13, + 169, + 55, + 198, + 126, + 135, + 201, + 236, + 5, + 141, + 8, + 6, + 10, + 149, + 225, + 237, + 160, + 165, + 171, + 101, + 70, + 204, + 164, + 80, + 148 + ], + "plaintext": [ + 10, + 255, + 36, + 180, + 197, + 170, + 69, + 184, + 28, + 224, + 142, + 194, + 67, + 155, + 228, + 70 + ], + "ciphertext": [ + 3, + 218, + 31, + 90, + 20, + 3, + 219, + 221, + 159, + 117, + 162, + 97, + 19, + 96, + 142, + 192 + ], + "tag": [ + 161, + 194, + 21, + 208, + 197, + 82, + 166, + 6, + 26, + 162, + 182, + 10, + 252, + 54, + 103, + 166 + ] + }, + { + "key": [ + 192, + 255, + 1, + 139, + 108, + 51, + 125, + 222, + 104, + 92, + 130, + 121, + 207, + 109, + 229, + 157, + 124, + 228, + 178, + 136, + 3, + 43, + 129, + 158, + 7, + 75, + 103, + 30, + 114, + 171, + 188, + 145 + ], + "nonce": [ + 241, + 46, + 107, + 30, + 133, + 248, + 126, + 244, + 201, + 204, + 187, + 123 + ], + "aad": [ + 5, + 119, + 232, + 210, + 140, + 14, + 158, + 92, + 222, + 60, + 139, + 42, + 26, + 42, + 168, + 226, + 252, + 62, + 200, + 233, + 103, + 104, + 64, + 95, + 207, + 189, + 98, + 59, + 231, + 252, + 78, + 46, + 57, + 92, + 89, + 181, + 179, + 168, + 234, + 17, + 126, + 242, + 17, + 50, + 11, + 193, + 248, + 87 + ], + "plaintext": [ + 247, + 81, + 43, + 191, + 162, + 212, + 13, + 20, + 190, + 113, + 183, + 15, + 112, + 112, + 28, + 153 + ], + "ciphertext": [ + 1, + 135, + 180, + 194, + 213, + 36, + 134, + 180, + 65, + 126, + 90, + 1, + 61, + 85, + 62, + 94 + ], + "tag": [ + 219, + 164, + 81, + 231, + 51, + 155, + 232, + 235, + 237, + 62, + 169, + 104, + 61, + 27, + 69, + 82 + ] + }, + { + "key": [ + 217, + 12, + 105, + 72, + 172, + 35, + 83, + 134, + 126, + 148, + 48, + 105, + 25, + 106, + 44, + 77, + 12, + 77, + 81, + 227, + 78, + 37, + 5, + 102, + 27, + 29, + 118, + 243, + 229, + 241, + 122, + 197 + ], + "nonce": [ + 7, + 229, + 98, + 63, + 71, + 78, + 47, + 15, + 233, + 244, + 199, + 210 + ], + "aad": [ + 13, + 233, + 117, + 116, + 174, + 27, + 198, + 211, + 239, + 6, + 198, + 206, + 3, + 81, + 60, + 164, + 125, + 255, + 71, + 40, + 128, + 62, + 10, + 172, + 197, + 5, + 100, + 238, + 50, + 183, + 117, + 253, + 83, + 95, + 92, + 140, + 48, + 24, + 101, + 80, + 217, + 155, + 255, + 111, + 56, + 74, + 242, + 221 + ], + "plaintext": [ + 138, + 159, + 177, + 179, + 132, + 192, + 209, + 114, + 128, + 153, + 164, + 247, + 203, + 0, + 47, + 7 + ], + "ciphertext": [ + 66, + 52, + 163, + 169, + 251, + 25, + 156, + 59, + 41, + 51, + 87, + 152, + 62, + 138, + 195, + 11 + ], + "tag": [ + 213, + 30, + 111, + 7, + 29, + 186, + 177, + 38, + 245, + 252, + 151, + 50, + 150, + 113, + 8, + 239 + ] + }, + { + "key": [ + 128, + 215, + 85, + 226, + 77, + 18, + 158, + 104, + 165, + 37, + 158, + 194, + 207, + 97, + 142, + 57, + 49, + 112, + 116, + 168, + 60, + 137, + 97, + 211, + 118, + 140, + 235, + 46, + 216, + 213, + 195, + 215 + ], + "nonce": [ + 117, + 152, + 192, + 123, + 167, + 177, + 108, + 209, + 44, + 245, + 8, + 19 + ], + "aad": [ + 14, + 148, + 244, + 196, + 143, + 208, + 201, + 105, + 12, + 133, + 58, + 210, + 165, + 225, + 151, + 197, + 222, + 38, + 33, + 55, + 182, + 158, + 208, + 205, + 250, + 40, + 216, + 209, + 36, + 19, + 228, + 255, + 255, + 21, + 55, + 78, + 28, + 204, + 176, + 66, + 62, + 142, + 216, + 41, + 169, + 84, + 163, + 53, + 237, + 112, + 90, + 39, + 42, + 215, + 249, + 171, + 209, + 5, + 124, + 132, + 155, + 176, + 213, + 75, + 118, + 142, + 157, + 121, + 135, + 158, + 197, + 82, + 70, + 28, + 192, + 74, + 219, + 108, + 160, + 4, + 12, + 93, + 213, + 188, + 115, + 61, + 33, + 169, + 55, + 2 + ], + "plaintext": [ + 94, + 127, + 209, + 41, + 140, + 79, + 21, + 170, + 15, + 28, + 30, + 71, + 33, + 122, + 167, + 169 + ], + "ciphertext": [ + 87, + 98, + 163, + 140, + 243, + 242, + 253, + 243, + 100, + 93, + 47, + 102, + 150, + 167, + 238, + 173 + ], + "tag": [ + 138, + 103, + 8, + 230, + 148, + 104, + 145, + 92, + 83, + 103, + 87, + 57, + 36, + 254, + 26, + 227 + ] + }, + { + "key": [ + 221, + 167, + 151, + 126, + 250, + 27, + 233, + 90, + 14, + 65, + 237, + 139, + 205, + 42, + 166, + 72, + 98, + 25, + 69, + 201, + 90, + 158, + 40, + 182, + 57, + 25, + 225, + 217, + 45, + 38, + 159, + 195 + ], + "nonce": [ + 5, + 63, + 110, + 27, + 228, + 42, + 248, + 137, + 74, + 110, + 134, + 160 + ], + "aad": [ + 203, + 81, + 20, + 160, + 1, + 152, + 147, + 57, + 101, + 116, + 39, + 235, + 136, + 50, + 157, + 108, + 233, + 198, + 150, + 148, + 220, + 145, + 166, + 155, + 117, + 87, + 214, + 33, + 132, + 229, + 120, + 50, + 236, + 118, + 209, + 98, + 252, + 156, + 71, + 73, + 11, + 179, + 215, + 142, + 88, + 153, + 68, + 92, + 236, + 248, + 93, + 54, + 203, + 31, + 7, + 254, + 213, + 163, + 216, + 42, + 175, + 126, + 149, + 144, + 243, + 237, + 116, + 173, + 19, + 177, + 60, + 138, + 219, + 252, + 127, + 41, + 215, + 177, + 81, + 68, + 141, + 111, + 41, + 209, + 29, + 11, + 211, + 208, + 59, + 118 + ], + "plaintext": [ + 111, + 169, + 176, + 129, + 118, + 233, + 150, + 57, + 39, + 175, + 186, + 30, + 95, + 150, + 154, + 66 + ], + "ciphertext": [ + 212, + 173, + 191, + 243, + 236, + 142, + 218, + 222, + 41, + 185, + 161, + 183, + 72, + 195, + 27, + 84 + ], + "tag": [ + 59, + 51, + 23, + 51, + 199, + 83, + 133, + 140, + 34, + 211, + 9, + 206, + 176, + 249, + 72, + 140 + ] + }, + { + "key": [ + 215, + 218, + 147, + 74, + 208, + 87, + 220, + 6, + 189, + 30, + 194, + 52, + 252, + 196, + 239, + 220, + 81, + 25, + 3, + 122, + 68, + 11, + 88, + 39, + 222, + 37, + 145, + 95, + 34, + 221, + 71, + 229 + ], + "nonce": [ + 27, + 84, + 196, + 234, + 55, + 210, + 57, + 94, + 247, + 13, + 204, + 114 + ], + "aad": [ + 115, + 93, + 228, + 89, + 106, + 128, + 230, + 78, + 56, + 161, + 42, + 178, + 78, + 247, + 56, + 129, + 214, + 237, + 59, + 83, + 60, + 178, + 193, + 1, + 2, + 92, + 54, + 21, + 172, + 210, + 17, + 65, + 80, + 254, + 236, + 168, + 74, + 222, + 78, + 86, + 59, + 196, + 163, + 0, + 235, + 74, + 12, + 217, + 122, + 24, + 74, + 41, + 63, + 10, + 192, + 99, + 228, + 243, + 198, + 30, + 127, + 205, + 179, + 49, + 188, + 198, + 69, + 159, + 175, + 175, + 14, + 45, + 218, + 136, + 31, + 52, + 235, + 113, + 127, + 78, + 232, + 196, + 182, + 137, + 13, + 62, + 245, + 151, + 33, + 243 + ], + "plaintext": [ + 134, + 213, + 86, + 118, + 88, + 54, + 17, + 152, + 52, + 130, + 7, + 237, + 231, + 164, + 109, + 166 + ], + "ciphertext": [ + 112, + 161, + 193, + 215, + 194, + 0, + 186, + 90, + 225, + 182, + 242, + 153, + 23, + 187, + 25, + 242 + ], + "tag": [ + 162, + 93, + 81, + 204, + 203, + 25, + 139, + 237, + 51, + 222, + 11, + 152, + 223, + 36, + 156, + 45 + ] + }, + { + "key": [ + 147, + 14, + 187, + 75, + 155, + 156, + 53, + 9, + 75, + 227, + 116, + 204, + 11, + 112, + 12, + 67, + 123, + 60, + 70, + 180, + 93, + 72, + 154, + 113, + 108, + 48, + 249, + 60, + 213, + 249, + 134, + 201 + ], + "nonce": [ + 122, + 33, + 229, + 254, + 189, + 130, + 236, + 155, + 151, + 191, + 190, + 131 + ], + "aad": [ + 159, + 46, + 213, + 246, + 207, + 158, + 45, + 101, + 5, + 211, + 201, + 154, + 143, + 129, + 167, + 223, + 197, + 101, + 141, + 208, + 133, + 235, + 169, + 102, + 200, + 179, + 32, + 98, + 48, + 151, + 58, + 8, + 110, + 195, + 111, + 233, + 72, + 87, + 59, + 174, + 225, + 8, + 252, + 169, + 65, + 188, + 229, + 61, + 173, + 115, + 24, + 8, + 119, + 205, + 73, + 121, + 118, + 32, + 156, + 26, + 223, + 138, + 152, + 97, + 240, + 33, + 85, + 96, + 223, + 6, + 76, + 175, + 14, + 242, + 249, + 148, + 69, + 193, + 24, + 22, + 245, + 184, + 222, + 234, + 254, + 221, + 104, + 43, + 95, + 178 + ], + "plaintext": [ + 152, + 0, + 134, + 102, + 93, + 8, + 163, + 101, + 246, + 187, + 226, + 10, + 229, + 17, + 22, + 247 + ], + "ciphertext": [ + 5, + 186, + 174, + 253, + 235, + 12, + 51, + 103, + 74, + 128, + 100, + 162, + 233, + 149, + 26, + 175 + ], + "tag": [ + 46, + 199, + 239, + 210, + 86, + 77, + 78, + 9, + 166, + 171, + 133, + 47, + 58, + 244, + 153, + 57 + ] + }, + { + "key": [ + 112, + 33, + 61, + 137, + 73, + 166, + 95, + 70, + 61, + 19, + 32, + 96, + 113, + 250, + 177, + 180, + 198, + 182, + 20, + 253, + 60, + 238, + 13, + 52, + 13, + 45, + 128, + 109, + 230, + 113, + 74, + 147 + ], + "nonce": [ + 248, + 82, + 157, + 62, + 79, + 21, + 92, + 187, + 31, + 251, + 61, + 10 + ], + "aad": [ + 17, + 35, + 96, + 219, + 57, + 184, + 103, + 218, + 186, + 170, + 29, + 119, + 123, + 216, + 129, + 223, + 33, + 4, + 182, + 159, + 186, + 21, + 164, + 243, + 122, + 131, + 47, + 93, + 163, + 138, + 216, + 168, + 199, + 196, + 109, + 185, + 62, + 91, + 78, + 173, + 248, + 185, + 165, + 167, + 85, + 8, + 173, + 20, + 87, + 153, + 76, + 19, + 60, + 90, + 200, + 85, + 9, + 238, + 223, + 177, + 59, + 144, + 162, + 207, + 108, + 86, + 163, + 199, + 120, + 88, + 41, + 57, + 54, + 32, + 8, + 96, + 139, + 8, + 249, + 196, + 134, + 106, + 14, + 56, + 116, + 69, + 114, + 17, + 69, + 152 + ], + "plaintext": [ + 71, + 212, + 122, + 95, + 211, + 42, + 42, + 65, + 111, + 146, + 28, + 199, + 240, + 12, + 15, + 129 + ], + "ciphertext": [ + 178, + 32, + 182, + 155, + 216, + 81, + 161, + 127, + 188, + 91, + 114, + 95, + 185, + 18, + 241, + 30 + ], + "tag": [ + 76, + 52, + 54, + 148, + 61, + 88, + 80, + 28, + 8, + 38, + 174, + 88, + 39, + 188, + 6, + 62 + ] + }, + { + "key": [ + 122, + 88, + 52, + 35, + 14, + 187, + 191, + 97, + 102, + 48, + 242, + 237, + 179, + 173, + 67, + 32, + 24, + 36, + 51, + 192, + 84, + 106, + 193, + 227, + 75, + 201, + 253, + 4, + 110, + 74, + 14, + 217 + ], + "nonce": [ + 210, + 125, + 214, + 33, + 43, + 109, + 239, + 220, + 187, + 199, + 1, + 187 + ], + "aad": [ + 59, + 193, + 47, + 59, + 184, + 142, + 164, + 248, + 162, + 24, + 73, + 89, + 187, + 156, + 214, + 137, + 17, + 167, + 132, + 88, + 178, + 126, + 155, + 82, + 140, + 206, + 202, + 254, + 127, + 19, + 243, + 3, + 220, + 113, + 71, + 34, + 135, + 95, + 38, + 177, + 54, + 209, + 138, + 58, + 207, + 232, + 43, + 83, + 173, + 94, + 19, + 199, + 31, + 63, + 109, + 180, + 176, + 253, + 89, + 255, + 253, + 156, + 212, + 66, + 44, + 115, + 242, + 195, + 26, + 201, + 112, + 16, + 229, + 237, + 245, + 149, + 13, + 201, + 8, + 232, + 223, + 61, + 126, + 28, + 191, + 124, + 52, + 168, + 82, + 30 + ], + "plaintext": [ + 180, + 222, + 241, + 37, + 20, + 39, + 173, + 224, + 100, + 169, + 97, + 78, + 53, + 61, + 218, + 63 + ], + "ciphertext": [ + 136, + 249, + 73, + 101, + 180, + 53, + 7, + 80, + 225, + 26, + 45, + 193, + 57, + 204, + 174, + 241 + ], + "tag": [ + 138, + 97, + 240, + 22, + 110, + 112, + 201, + 191, + 221, + 25, + 132, + 3, + 229, + 58, + 104, + 165 + ] + }, + { + "key": [ + 195, + 241, + 5, + 134, + 242, + 70, + 170, + 202, + 220, + 206, + 55, + 1, + 68, + 23, + 112, + 192, + 60, + 254, + 201, + 64, + 175, + 225, + 144, + 140, + 76, + 83, + 125, + 244, + 224, + 28, + 80, + 160 + ], + "nonce": [ + 79, + 82, + 250, + 161, + 250, + 103, + 160, + 229, + 244, + 25, + 100, + 82 + ], + "aad": [ + 70, + 249, + 162, + 43, + 78, + 82, + 225, + 82, + 101, + 19, + 169, + 82, + 219, + 238, + 59, + 145, + 246, + 149, + 149, + 80, + 30, + 1, + 119, + 213, + 15, + 243, + 100, + 99, + 133, + 136, + 192, + 141, + 146, + 250, + 184, + 197, + 138, + 150, + 155, + 220, + 200, + 76, + 70, + 141, + 132, + 152, + 196, + 240, + 99, + 146, + 185, + 158, + 213, + 224, + 196, + 132, + 80, + 127, + 196, + 141, + 193, + 141, + 135, + 196, + 14, + 46, + 216, + 72, + 180, + 49, + 80, + 190, + 157, + 54, + 241, + 76, + 242, + 206, + 241, + 49, + 11, + 164, + 167, + 69, + 173, + 204, + 123, + 220, + 65, + 246 + ], + "plaintext": [ + 121, + 217, + 126, + 163, + 162, + 237, + 214, + 80, + 69, + 130, + 30, + 167, + 69, + 164, + 71, + 66 + ], + "ciphertext": [ + 86, + 12, + 247, + 22, + 229, + 97, + 144, + 233, + 57, + 124, + 47, + 16, + 54, + 41, + 235, + 31 + ], + "tag": [ + 255, + 124, + 145, + 36, + 135, + 150, + 68, + 232, + 5, + 85, + 104, + 125, + 39, + 60, + 85, + 216 + ] + }, + { + "key": [ + 173, + 112, + 235, + 207, + 136, + 158, + 136, + 184, + 103, + 222, + 208, + 228, + 131, + 140, + 166, + 109, + 105, + 145, + 73, + 144, + 70, + 165, + 103, + 29, + 153, + 233, + 30, + 212, + 99, + 174, + 120, + 177 + ], + "nonce": [ + 86, + 30, + 19, + 179, + 53, + 113, + 143, + 203, + 238, + 54, + 65, + 0 + ], + "aad": [ + 224, + 55, + 189, + 115, + 6, + 238, + 193, + 133, + 185, + 203, + 78, + 59, + 242, + 149, + 35, + 45, + 161, + 144, + 5, + 149, + 112, + 134, + 214, + 46, + 111, + 179, + 66, + 40, + 79, + 5, + 254, + 170, + 14, + 129, + 214, + 201, + 80, + 113, + 231, + 228, + 215, + 182, + 170, + 215, + 176, + 15, + 126, + 120, + 99, + 221, + 15, + 193, + 99, + 3, + 168, + 48, + 75, + 184, + 133, + 83, + 5, + 242, + 128, + 103, + 244, + 190, + 113, + 238, + 217, + 95, + 249, + 14, + 4, + 99, + 130, + 17, + 98, + 41, + 240, + 253, + 61, + 44, + 62, + 242, + 232, + 126, + 13, + 14, + 121, + 80 + ], + "plaintext": [ + 130, + 213, + 86, + 136, + 114, + 164, + 206, + 241, + 34, + 56, + 192, + 254, + 177, + 79, + 15, + 180 + ], + "ciphertext": [ + 119, + 28, + 109, + 9, + 31, + 129, + 144, + 221, + 189, + 184, + 136, + 109, + 156, + 226, + 235, + 213 + ], + "tag": [ + 80, + 9, + 171, + 209, + 235, + 235, + 38, + 218, + 184, + 82, + 52, + 110, + 166, + 216, + 174, + 227 + ] + }, + { + "key": [ + 164, + 82, + 250, + 36, + 179, + 129, + 231, + 22, + 94, + 233, + 15, + 51, + 113, + 194, + 176, + 219, + 33, + 118, + 248, + 72, + 160, + 53, + 76, + 120, + 233, + 47, + 47, + 31, + 137, + 187, + 197, + 17 + ], + "nonce": [ + 75, + 217, + 4, + 223, + 225, + 130, + 65, + 235, + 84, + 85, + 217, + 18 + ], + "aad": [ + 100, + 241, + 169, + 210, + 29, + 235, + 24, + 60, + 255, + 132, + 241, + 174, + 245, + 190, + 131, + 219, + 252, + 114, + 226, + 117, + 242, + 41, + 235, + 93, + 89, + 172, + 225, + 67, + 96, + 94, + 137, + 1, + 223, + 168, + 244, + 114, + 75, + 226, + 76, + 134, + 181, + 66, + 155, + 200, + 75, + 98, + 153, + 113, + 254, + 31, + 150, + 99, + 183, + 83, + 116, + 39, + 180, + 93, + 251, + 103, + 213, + 240, + 69, + 6, + 223, + 78, + 226, + 195, + 61, + 127, + 21, + 175, + 159, + 110, + 134, + 5, + 139, + 19, + 27, + 126, + 96, + 66, + 180, + 58, + 85, + 191, + 105, + 21, + 240, + 72 + ], + "plaintext": [ + 63, + 67, + 223, + 35, + 234, + 148, + 15, + 54, + 128, + 164, + 182, + 121, + 181, + 109, + 181, + 121 + ], + "ciphertext": [ + 192, + 84, + 151, + 76, + 69, + 98, + 248, + 83, + 106, + 239, + 39, + 52, + 241, + 14, + 9, + 252 + ], + "tag": [ + 44, + 92, + 175, + 175, + 123, + 31, + 117, + 129, + 197, + 236, + 19, + 8, + 9, + 148, + 227, + 60 + ] + }, + { + "key": [ + 32, + 158, + 163, + 196, + 221, + 4, + 32, + 164, + 214, + 61, + 187, + 114, + 9, + 154, + 2, + 2, + 201, + 176, + 112, + 159, + 59, + 18, + 33, + 86, + 95, + 137, + 5, + 17, + 238, + 248, + 0, + 91 + ], + "nonce": [ + 67, + 119, + 80, + 131, + 228, + 0, + 136, + 22, + 18, + 159, + 93, + 64 + ], + "aad": [ + 154, + 188, + 101, + 58, + 35, + 71, + 252, + 110, + 90, + 140, + 185, + 189, + 194, + 81, + 223, + 247, + 197, + 97, + 9, + 121, + 124, + 56, + 116, + 148, + 192, + 237, + 85, + 87, + 3, + 48, + 150, + 30, + 181, + 177, + 16, + 135, + 96, + 62, + 8, + 173, + 41, + 61, + 13, + 213, + 85, + 113, + 0, + 142, + 98, + 209, + 22, + 63, + 103, + 207, + 130, + 158, + 40, + 210, + 123, + 235, + 166, + 85, + 83, + 189, + 17, + 216, + 131, + 143, + 138, + 122, + 95, + 31, + 224, + 85, + 0, + 190, + 251, + 175, + 151, + 131, + 152, + 1, + 233, + 158, + 207, + 153, + 136, + 130, + 199, + 7 + ], + "plaintext": [ + 180, + 150, + 127, + 140, + 79, + 177, + 179, + 75, + 111, + 244, + 58, + 34, + 211, + 79, + 174, + 92 + ], + "ciphertext": [ + 168, + 210, + 42, + 110, + 37, + 35, + 41, + 56, + 211, + 248, + 96, + 10, + 102, + 190, + 128, + 218 + ], + "tag": [ + 46, + 249, + 60, + 192, + 60, + 23, + 187, + 251, + 102, + 38, + 20, + 70, + 151, + 253, + 36, + 34 + ] + }, + { + "key": [ + 218, + 189, + 99, + 172, + 82, + 116, + 178, + 104, + 66, + 194, + 105, + 92, + 152, + 80, + 215, + 172, + 204, + 22, + 147, + 238, + 42, + 238, + 225, + 226, + 225, + 51, + 139, + 187, + 197, + 184, + 15, + 135 + ], + "nonce": [ + 253, + 103, + 144, + 214, + 32, + 241, + 40, + 112, + 177, + 217, + 155, + 49 + ], + "aad": [ + 228, + 160, + 107, + 155, + 32, + 90, + 127, + 170, + 219, + 33, + 220, + 127, + 234, + 138, + 13, + 224, + 224, + 19, + 215, + 23, + 182, + 27, + 36, + 236, + 66, + 248, + 26, + 252, + 140, + 219, + 192, + 85, + 87, + 62, + 151, + 19, + 117, + 218, + 47, + 165, + 16, + 58, + 9, + 19, + 23, + 234, + 177, + 59, + 106, + 17, + 14, + 162, + 17, + 175, + 37, + 127, + 234, + 191, + 82, + 171, + 175, + 236, + 35, + 253, + 91, + 17, + 75, + 1, + 61, + 92, + 5, + 33, + 153, + 2, + 5, + 115, + 248, + 183, + 183, + 174, + 105, + 88, + 247, + 51, + 232, + 126, + 250, + 4, + 38, + 194 + ], + "plaintext": [ + 74, + 40, + 4, + 143, + 86, + 131, + 103, + 154, + 85, + 118, + 48, + 166, + 97, + 240, + 48, + 226 + ], + "ciphertext": [ + 25, + 109, + 3, + 69, + 223, + 37, + 155, + 71, + 102, + 91, + 194, + 51, + 183, + 152, + 235, + 186 + ], + "tag": [ + 176, + 114, + 157, + 139, + 66, + 122, + 208, + 72, + 167, + 57, + 108, + 237, + 242, + 37, + 115, + 56 + ] + }, + { + "key": [ + 178, + 56, + 223, + 94, + 82, + 230, + 73, + 212, + 176, + 160, + 94, + 83, + 2, + 10, + 197, + 158, + 125, + 91, + 244, + 155, + 141, + 4, + 248, + 195, + 12, + 53, + 110, + 214, + 45, + 186, + 158, + 209 + ], + "nonce": [ + 241, + 83, + 240, + 147, + 201, + 163, + 71, + 159, + 153, + 158, + 218, + 4 + ], + "aad": [ + 69, + 181, + 223, + 12, + 21, + 20, + 14, + 92, + 231, + 161, + 159, + 78, + 2, + 131, + 78, + 96, + 39, + 151, + 30, + 62, + 14, + 113, + 150, + 38, + 194, + 144, + 129, + 166, + 48, + 30, + 149, + 199, + 18, + 20, + 52, + 90, + 250, + 193, + 144, + 139, + 183, + 95, + 242, + 211, + 40, + 18, + 97, + 230, + 197, + 244, + 29, + 196, + 228, + 121, + 111, + 5, + 65, + 116, + 166, + 79, + 142, + 23, + 127, + 63, + 51, + 50, + 30, + 223, + 189, + 38, + 62, + 32, + 65, + 53, + 105, + 148, + 40, + 160, + 159, + 52, + 235, + 52, + 66, + 17, + 191, + 185, + 250, + 201, + 175, + 186 + ], + "plaintext": [ + 212, + 142, + 119, + 151, + 102, + 175, + 167, + 61, + 126, + 4, + 252, + 111, + 195, + 250, + 130, + 94 + ], + "ciphertext": [ + 177, + 152, + 158, + 181, + 16, + 132, + 61, + 143, + 53, + 32, + 93, + 195, + 249, + 73, + 82, + 47 + ], + "tag": [ + 97, + 96, + 137, + 153, + 7, + 41, + 34, + 143, + 103, + 48, + 153, + 81, + 72, + 36, + 217, + 180 + ] + }, + { + "key": [ + 243, + 220, + 36, + 86, + 211, + 184, + 148, + 117, + 145, + 162, + 216, + 43, + 115, + 25, + 34, + 107, + 15, + 52, + 108, + 212, + 54, + 27, + 204, + 19, + 181, + 109, + 164, + 62, + 7, + 42, + 39, + 116 + ], + "nonce": [ + 122, + 138, + 203, + 90, + 132, + 215, + 208, + 30, + 60, + 0, + 73, + 158 + ], + "aad": [ + 94, + 107, + 224, + 105, + 239, + 254, + 226, + 125, + 52, + 168, + 8, + 124, + 13, + 25, + 63, + 159, + 19, + 230, + 68, + 13, + 201, + 250, + 191, + 226, + 79, + 108, + 134, + 127, + 131, + 29, + 6, + 120, + 157, + 13, + 206, + 146, + 178, + 227, + 255, + 58, + 185, + 254, + 20, + 32, + 42, + 139, + 66, + 243, + 132, + 194, + 94, + 63, + 55, + 83, + 221, + 80, + 62, + 201, + 7, + 169, + 184, + 119, + 241, + 112, + 125, + 100, + 228, + 172, + 66, + 144, + 154, + 125, + 238, + 0, + 200, + 124, + 74, + 9, + 208, + 77, + 227, + 49, + 81, + 84, + 96, + 237, + 16, + 31, + 81, + 135 + ], + "plaintext": [ + 173, + 7, + 93, + 169, + 8, + 35, + 31, + 249, + 170, + 227, + 13, + 170, + 107, + 132, + 113, + 67 + ], + "ciphertext": [ + 159, + 34, + 79, + 42, + 26, + 31, + 186, + 173, + 232, + 184, + 123, + 116, + 137, + 113, + 192, + 172 + ], + "tag": [ + 203, + 80, + 137, + 217, + 223, + 174, + 191, + 152, + 228, + 179, + 110, + 188, + 95, + 154, + 26, + 80 + ] + }, + { + "key": [ + 245, + 165, + 107, + 105, + 161, + 86, + 44, + 119, + 232, + 237, + 235, + 195, + 39, + 162, + 2, + 149, + 194, + 235, + 167, + 212, + 6, + 216, + 153, + 166, + 34, + 197, + 53, + 57, + 98, + 108, + 157, + 114 + ], + "nonce": [ + 163, + 149, + 184, + 172, + 164, + 80, + 138, + 106, + 95, + 60, + 180, + 216 + ], + "aad": [ + 46, + 79, + 202, + 43, + 22, + 62, + 68, + 3, + 151, + 23, + 22, + 1, + 83, + 134, + 205, + 129, + 189, + 209, + 229, + 127, + 0, + 242, + 147, + 109, + 164, + 8, + 9, + 131, + 65, + 1, + 31, + 38, + 68, + 163, + 141, + 218, + 215, + 153, + 247, + 14, + 170, + 84, + 246, + 228, + 48, + 212, + 133, + 63, + 242, + 185, + 196, + 74, + 53, + 18, + 54, + 112, + 135, + 154, + 131, + 18, + 11, + 213, + 85, + 199, + 107, + 149, + 183, + 13, + 224, + 200, + 5, + 79, + 157, + 8, + 83, + 154, + 87, + 149, + 231, + 10, + 36, + 70, + 215, + 185, + 250, + 179, + 247, + 136, + 124, + 107 + ], + "plaintext": [ + 125, + 228, + 99, + 135, + 1, + 189, + 43, + 96, + 13, + 127, + 141, + 38, + 218, + 122, + 117, + 188 + ], + "ciphertext": [ + 101, + 8, + 190, + 38, + 152, + 186, + 152, + 137, + 180, + 228, + 69, + 185, + 145, + 144, + 165, + 197 + ], + "tag": [ + 51, + 148, + 16, + 111, + 37, + 124, + 46, + 21, + 200, + 21, + 67, + 15, + 96, + 188, + 36, + 186 + ] + }, + { + "key": [ + 55, + 99, + 113, + 167, + 128, + 148, + 114, + 86, + 197, + 47, + 7, + 216, + 11, + 178, + 90, + 77, + 126, + 145, + 156, + 168, + 189, + 105, + 59, + 26, + 12, + 203, + 202, + 116, + 141, + 44, + 230, + 32 + ], + "nonce": [ + 39, + 215, + 23, + 15, + 111, + 112, + 242, + 252, + 64, + 223, + 202, + 120 + ], + "aad": [ + 39, + 44, + 53, + 89, + 57, + 138, + 215, + 116, + 250, + 75, + 104, + 149, + 175, + 201, + 40, + 112, + 178, + 185, + 45, + 49, + 15, + 160, + 222, + 191, + 11, + 121, + 96, + 225, + 254, + 56, + 191, + 218, + 100, + 172, + 210, + 254, + 242, + 109, + 107, + 23, + 125, + 138, + 177, + 29, + 138, + 252, + 238, + 231, + 115, + 116, + 198, + 193, + 138, + 212, + 5, + 213, + 174, + 50, + 58, + 214, + 95, + 182, + 176, + 79, + 12, + 128, + 147, + 25, + 19, + 55, + 18, + 244, + 118, + 54, + 197, + 224, + 66, + 241, + 94, + 208, + 47, + 55, + 238, + 122, + 16, + 198, + 67, + 215, + 177, + 120 + ], + "plaintext": [ + 122, + 39, + 159, + 159, + 133, + 104, + 183, + 195, + 7, + 73, + 5, + 73, + 178, + 89, + 34, + 108 + ], + "ciphertext": [ + 50, + 40, + 67, + 121, + 216, + 196, + 14, + 193, + 142, + 229, + 119, + 64, + 133, + 215, + 216, + 112 + ], + "tag": [ + 220, + 222, + 225, + 167, + 87, + 249, + 117, + 140, + 148, + 77, + 41, + 107, + 29, + 171, + 231, + 178 + ] + }, + { + "key": [ + 130, + 196, + 241, + 46, + 238, + 195, + 178, + 211, + 209, + 87, + 176, + 249, + 146, + 210, + 146, + 178, + 55, + 71, + 141, + 44, + 236, + 193, + 213, + 241, + 97, + 56, + 155, + 151, + 249, + 153, + 5, + 122 + ], + "nonce": [ + 123, + 64, + 178, + 15, + 95, + 57, + 113, + 119, + 153, + 14, + 242, + 209 + ], + "aad": [], + "plaintext": [ + 152, + 42, + 41, + 110, + 225, + 205, + 112, + 134, + 175, + 173, + 151, + 105, + 69 + ], + "ciphertext": [ + 236, + 142, + 5, + 160, + 71, + 29, + 107, + 67, + 165, + 156, + 165, + 51, + 95 + ], + "tag": [ + 17, + 61, + 222, + 175, + 198, + 35, + 115, + 202, + 194, + 245, + 149, + 27, + 185, + 22, + 82, + 73 + ] + }, + { + "key": [ + 219, + 67, + 64, + 175, + 47, + 131, + 90, + 108, + 109, + 126, + 160, + 202, + 157, + 131, + 202, + 129, + 186, + 2, + 194, + 155, + 116, + 16, + 242, + 33, + 203, + 96, + 113, + 17, + 78, + 57, + 50, + 64 + ], + "nonce": [ + 64, + 228, + 56, + 53, + 125, + 216, + 10, + 133, + 202, + 195, + 52, + 158 + ], + "aad": [], + "plaintext": [ + 141, + 219, + 51, + 151, + 189, + 66, + 133, + 49, + 147, + 203, + 15, + 128, + 201 + ], + "ciphertext": [ + 182, + 148, + 17, + 140, + 133, + 196, + 26, + 191, + 105, + 226, + 41, + 203, + 15 + ], + "tag": [ + 192, + 127, + 27, + 138, + 175, + 189, + 21, + 47, + 105, + 126, + 182, + 127, + 42, + 133, + 254, + 69 + ] + }, + { + "key": [ + 172, + 173, + 74, + 53, + 136, + 167, + 197, + 236, + 103, + 131, + 43, + 174, + 226, + 66, + 176, + 7, + 200, + 244, + 46, + 215, + 66, + 93, + 90, + 126, + 87, + 177, + 7, + 11, + 123, + 226, + 103, + 126 + ], + "nonce": [ + 177, + 23, + 4, + 186, + 54, + 138, + 186, + 223, + 139, + 12, + 43, + 152 + ], + "aad": [], + "plaintext": [ + 38, + 86, + 181, + 251, + 236, + 138, + 54, + 102, + 202, + 213, + 244, + 96, + 183 + ], + "ciphertext": [ + 53, + 199, + 17, + 76, + 171, + 227, + 146, + 3, + 223, + 25, + 65, + 58, + 153 + ], + "tag": [ + 22, + 244, + 199, + 229, + 190, + 207, + 0, + 219, + 18, + 35, + 71, + 106, + 20, + 196, + 62, + 188 + ] + }, + { + "key": [ + 229, + 160, + 235, + 146, + 204, + 43, + 6, + 78, + 27, + 200, + 8, + 145, + 250, + 241, + 250, + 181, + 233, + 161, + 122, + 156, + 58, + 152, + 78, + 37, + 65, + 103, + 32, + 227, + 14, + 108, + 43, + 33 + ], + "nonce": [ + 71, + 66, + 53, + 124, + 51, + 89, + 19, + 21, + 63, + 240, + 235, + 15 + ], + "aad": [], + "plaintext": [ + 132, + 153, + 137, + 62, + 22, + 176, + 186, + 139, + 0, + 125, + 84, + 102, + 90 + ], + "ciphertext": [ + 235, + 142, + 97, + 117, + 241, + 254, + 56, + 235, + 26, + 207, + 149, + 253, + 81 + ], + "tag": [ + 136, + 168, + 183, + 75, + 183, + 79, + 218, + 85, + 62, + 145, + 2, + 10, + 35, + 222, + 237, + 69 + ] + }, + { + "key": [ + 231, + 140, + 71, + 112, + 83, + 245, + 218, + 229, + 192, + 41, + 65, + 6, + 29, + 57, + 123, + 195, + 141, + 218, + 93, + 227, + 201, + 200, + 102, + 10, + 25, + 222, + 102, + 197, + 108, + 87, + 253, + 34 + ], + "nonce": [ + 79, + 82, + 198, + 124, + 43, + 183, + 72, + 209, + 146, + 165, + 164, + 226 + ], + "aad": [], + "plaintext": [ + 145, + 89, + 62, + 33, + 225, + 248, + 131, + 175, + 92, + 50, + 217, + 190, + 7 + ], + "ciphertext": [ + 227, + 127, + 188, + 86, + 176, + 175, + 32, + 10, + 122, + 161, + 187, + 227, + 78 + ], + "tag": [ + 41, + 254, + 84, + 234, + 172, + 207, + 94, + 56, + 38, + 1, + 161, + 86, + 3, + 201, + 242, + 140 + ] + }, + { + "key": [ + 208, + 177, + 52, + 130, + 3, + 118, + 57, + 170, + 121, + 116, + 113, + 165, + 43, + 96, + 243, + 83, + 180, + 46, + 14, + 210, + 113, + 218, + 164, + 243, + 138, + 146, + 147, + 25, + 28, + 183, + 139, + 114 + ], + "nonce": [ + 64, + 251, + 124, + 174, + 70, + 173, + 243, + 119, + 27, + 243, + 117, + 106 + ], + "aad": [], + "plaintext": [ + 147, + 143, + 64, + 172, + 142, + 14, + 59, + 149, + 106, + 172, + 94, + 145, + 132 + ], + "ciphertext": [ + 125, + 202, + 5, + 161, + 171, + 232, + 25, + 40, + 204, + 251, + 33, + 100, + 221 + ], + "tag": [ + 94, + 165, + 62, + 225, + 112, + 217, + 171, + 95, + 108, + 192, + 71, + 133, + 78, + 71, + 207, + 96 + ] + }, + { + "key": [ + 70, + 218, + 94, + 198, + 136, + 254, + 234, + 215, + 106, + 29, + 220, + 214, + 11, + 239, + 180, + 80, + 116, + 162, + 239, + 34, + 84, + 215, + 190, + 38, + 171, + 223, + 216, + 70, + 41, + 219, + 188, + 50 + ], + "nonce": [ + 159, + 179, + 178, + 176, + 57, + 37, + 244, + 118, + 252, + 154, + 53, + 243 + ], + "aad": [], + "plaintext": [ + 164, + 26, + 220, + 159, + 180, + 226, + 90, + 138, + 222, + 241, + 24, + 14, + 200 + ], + "ciphertext": [ + 245, + 93, + 76, + 190, + 155, + 20, + 206, + 160, + 81, + 254, + 122, + 36, + 119 + ], + "tag": [ + 130, + 71, + 83, + 218, + 1, + 19, + 210, + 17, + 134, + 105, + 157, + 187, + 54, + 108, + 5, + 137 + ] + }, + { + "key": [ + 222, + 58, + 223, + 137, + 242, + 254, + 36, + 108, + 7, + 176, + 206, + 3, + 95, + 74, + 247, + 60, + 242, + 246, + 94, + 80, + 52, + 220, + 254, + 207, + 233, + 215, + 105, + 10, + 225, + 189, + 189, + 150 + ], + "nonce": [ + 169, + 74, + 164, + 223, + 13, + 132, + 81, + 100, + 74, + 80, + 86, + 192 + ], + "aad": [], + "plaintext": [ + 150, + 130, + 95, + 109, + 99, + 1, + 219, + 20, + 168, + 215, + 143, + 194, + 244 + ], + "ciphertext": [ + 120, + 76, + 108, + 60, + 36, + 160, + 34, + 99, + 124, + 188, + 144, + 124, + 72 + ], + "tag": [ + 30, + 234, + 237, + 220, + 219, + 76, + 114, + 196, + 232, + 150, + 105, + 80, + 163, + 25, + 164, + 239 + ] + }, + { + "key": [ + 3, + 195, + 98, + 40, + 136, + 131, + 50, + 127, + 98, + 137, + 188, + 24, + 36, + 225, + 195, + 41, + 206, + 72, + 94, + 12, + 224, + 232, + 211, + 64, + 82, + 69, + 40, + 60, + 240, + 242, + 234, + 226 + ], + "nonce": [ + 93, + 233, + 248, + 130, + 201, + 21, + 199, + 39, + 41, + 178, + 36, + 92 + ], + "aad": [], + "plaintext": [ + 245, + 193, + 200, + 212, + 29, + 224, + 29, + 156, + 8, + 217, + 244, + 126, + 206 + ], + "ciphertext": [ + 97, + 175, + 98, + 25, + 83, + 161, + 38, + 162, + 209, + 222, + 85, + 158, + 146 + ], + "tag": [ + 251, + 222, + 183, + 97, + 35, + 143, + 43, + 112, + 197, + 251, + 61, + 222, + 10, + 121, + 120, + 243 + ] + }, + { + "key": [ + 233, + 234, + 215, + 197, + 145, + 0, + 183, + 104, + 170, + 99, + 103, + 216, + 12, + 4, + 164, + 155, + 205, + 25, + 250, + 140, + 194, + 225, + 88, + 220, + 142, + 222, + 236, + 62, + 163, + 155, + 101, + 125 + ], + "nonce": [ + 232, + 24, + 84, + 102, + 93, + 46, + 10, + 151, + 21, + 15, + 186, + 179 + ], + "aad": [], + "plaintext": [ + 248, + 204, + 246, + 156, + 82, + 168, + 115, + 105, + 83, + 103, + 164, + 41, + 64 + ], + "ciphertext": [ + 175, + 42, + 113, + 153, + 96, + 46, + 233, + 237, + 32, + 32, + 199, + 180, + 205 + ], + "tag": [ + 41, + 113, + 89, + 69, + 171, + 28, + 3, + 78, + 207, + 205, + 145, + 164, + 102, + 252, + 130, + 46 + ] + }, + { + "key": [ + 188, + 62, + 91, + 15, + 228, + 35, + 32, + 89, + 4, + 195, + 47, + 135, + 11, + 154, + 222, + 201, + 215, + 54, + 161, + 97, + 102, + 36, + 4, + 62, + 129, + 149, + 51, + 250, + 151, + 237, + 155, + 121 + ], + "nonce": [ + 51, + 95, + 229, + 24, + 1, + 53, + 103, + 60, + 225, + 167, + 81, + 68 + ], + "aad": [], + "plaintext": [ + 41, + 93, + 249, + 102, + 94, + 239, + 153, + 146, + 4, + 249, + 42, + 207, + 36 + ], + "ciphertext": [ + 58, + 194, + 168, + 161, + 181, + 5, + 168, + 70, + 119, + 173, + 253, + 179, + 150 + ], + "tag": [ + 33, + 242, + 10, + 160, + 187, + 119, + 212, + 109, + 114, + 144, + 188, + 156, + 151, + 167, + 167, + 189 + ] + }, + { + "key": [ + 206, + 136, + 156, + 115, + 224, + 214, + 78, + 39, + 42, + 186, + 75, + 249, + 119, + 122, + 252, + 126, + 230, + 69, + 125, + 220, + 150, + 38, + 173, + 147, + 23, + 8, + 237, + 117, + 48, + 215, + 27, + 153 + ], + "nonce": [ + 254, + 97, + 166, + 205, + 166, + 47, + 236, + 212, + 227, + 176, + 197, + 98 + ], + "aad": [], + "plaintext": [ + 226, + 174, + 64, + 186, + 91, + 65, + 3, + 177, + 163, + 6, + 108, + 27, + 87 + ], + "ciphertext": [ + 24, + 90, + 163, + 80, + 138, + 55, + 230, + 113, + 43, + 40, + 25, + 30, + 194 + ], + "tag": [ + 158, + 193, + 213, + 103, + 88, + 90, + 164, + 103, + 115, + 12, + 206, + 146, + 229, + 54, + 114, + 142 + ] + }, + { + "key": [ + 65, + 224, + 203, + 26, + 237, + 47, + 229, + 62, + 11, + 104, + 138, + 203, + 4, + 42, + 12, + 113, + 10, + 60, + 58, + 227, + 32, + 91, + 7, + 192, + 175, + 81, + 145, + 7, + 58, + 189, + 251, + 169 + ], + "nonce": [ + 47, + 86, + 227, + 82, + 22, + 216, + 141, + 52, + 208, + 143, + 104, + 114 + ], + "aad": [], + "plaintext": [ + 100, + 130, + 223, + 14, + 65, + 80, + 231, + 61, + 172, + 81, + 220, + 50, + 32 + ], + "ciphertext": [ + 156, + 176, + 155, + 153, + 39, + 223, + 190, + 15, + 34, + 142, + 10, + 67, + 7 + ], + "tag": [ + 254, + 126, + 135, + 165, + 150, + 214, + 62, + 42, + 178, + 170, + 228, + 107, + 100, + 212, + 102, + 232 + ] + }, + { + "key": [ + 82, + 167, + 102, + 41, + 84, + 213, + 37, + 203, + 0, + 96, + 43, + 31, + 245, + 233, + 55, + 212, + 16, + 101, + 172, + 75, + 146, + 30, + 40, + 79, + 250, + 199, + 60, + 4, + 207, + 212, + 98, + 160 + ], + "nonce": [ + 186, + 255, + 231, + 56, + 86, + 171, + 26, + 71, + 251, + 31, + 238, + 191 + ], + "aad": [], + "plaintext": [ + 157, + 11, + 92, + 167, + 18, + 249, + 124, + 170, + 24, + 117, + 211, + 173, + 135 + ], + "ciphertext": [ + 253, + 1, + 22, + 83, + 128, + 174, + 221, + 107, + 226, + 38, + 166, + 106, + 243 + ], + "tag": [ + 53, + 164, + 146, + 227, + 153, + 82, + 194, + 100, + 86, + 133, + 11, + 1, + 114, + 215, + 35, + 209 + ] + }, + { + "key": [ + 196, + 186, + 219, + 151, + 102, + 152, + 111, + 174, + 184, + 136, + 177, + 219, + 51, + 6, + 10, + 156, + 209, + 240, + 46, + 26, + 254, + 122, + 170, + 234, + 7, + 45, + 144, + 87, + 80, + 203, + 115, + 82 + ], + "nonce": [ + 204, + 105, + 102, + 233, + 216, + 26, + 41, + 138, + 86, + 20, + 22, + 212 + ], + "aad": [], + "plaintext": [ + 222, + 104, + 251, + 81, + 115, + 27, + 69, + 231, + 194, + 197, + 6, + 57, + 35 + ], + "ciphertext": [ + 245, + 190, + 65, + 242, + 200, + 195, + 46, + 1, + 9, + 141, + 67, + 48, + 87 + ], + "tag": [ + 200, + 43, + 27, + 1, + 41, + 22, + 171, + 110, + 216, + 81, + 213, + 152, + 41, + 218, + 216, + 171 + ] + }, + { + "key": [ + 218, + 216, + 157, + 155, + 233, + 187, + 161, + 56, + 205, + 207, + 135, + 82, + 196, + 91, + 87, + 157, + 126, + 39, + 195, + 219, + 180, + 15, + 83, + 231, + 113, + 221, + 140, + 253, + 80, + 10, + 162, + 213 + ], + "nonce": [ + 207, + 178, + 174, + 200, + 44, + 250, + 108, + 125, + 137, + 238, + 114, + 255 + ], + "aad": [ + 110, + 67, + 120, + 74, + 145, + 133, + 26, + 119, + 102, + 122, + 2, + 25, + 142, + 40, + 220, + 50 + ], + "plaintext": [ + 181, + 38, + 186, + 16, + 80, + 23, + 125, + 5, + 176, + 247, + 47, + 141, + 103 + ], + "ciphertext": [ + 139, + 41, + 230, + 110, + 146, + 78, + 202, + 232, + 79, + 109, + 143, + 125, + 104 + ], + "tag": [ + 30, + 54, + 88, + 5, + 200, + 242, + 139, + 46, + 216, + 165, + 202, + 223, + 217, + 7, + 145, + 88 + ] + }, + { + "key": [ + 13, + 53, + 211, + 219, + 217, + 156, + 213, + 224, + 136, + 202, + 246, + 134, + 177, + 206, + 173, + 157, + 239, + 224, + 198, + 0, + 20, + 99, + 233, + 46, + 109, + 159, + 205, + 194, + 176, + 220, + 186, + 246 + ], + "nonce": [ + 249, + 19, + 158, + 185, + 54, + 141, + 105, + 172, + 72, + 71, + 157, + 31 + ], + "aad": [ + 130, + 92, + 199, + 19, + 187, + 65, + 199, + 137, + 193, + 172, + 224, + 242, + 208, + 221, + 51, + 119 + ], + "plaintext": [ + 94, + 33, + 3, + 235, + 62, + 115, + 146, + 152, + 201, + 245, + 198, + 186, + 14 + ], + "ciphertext": [ + 143, + 243, + 135, + 14, + 236, + 1, + 118, + 217, + 240, + 198, + 193, + 177, + 162 + ], + "tag": [ + 52, + 66, + 52, + 71, + 85, + 56, + 220, + 120, + 192, + 31, + 36, + 159, + 103, + 62, + 8, + 98 + ] + }, + { + "key": [ + 211, + 93, + 100, + 241, + 135, + 43, + 220, + 180, + 34, + 34, + 143, + 13, + 99, + 248, + 228, + 137, + 119, + 237, + 104, + 209, + 67, + 246, + 72, + 174, + 44, + 216, + 82, + 249, + 68, + 176, + 230, + 221 + ], + "nonce": [ + 11, + 33, + 132, + 170, + 219, + 232, + 181, + 21, + 146, + 77, + 218, + 94 + ], + "aad": [ + 136, + 143, + 50, + 141, + 158, + 158, + 235, + 187, + 156, + 178, + 112, + 75, + 91, + 136, + 13, + 102 + ], + "plaintext": [ + 200, + 249, + 153, + 170, + 26, + 8, + 135, + 29, + 116, + 219, + 73, + 12, + 243 + ], + "ciphertext": [ + 173, + 13, + 94, + 124, + 16, + 101, + 163, + 75, + 39, + 162, + 86, + 209, + 68 + ], + "tag": [ + 140, + 142, + 112, + 118, + 149, + 15, + 127, + 42, + 235, + 166, + 46, + 30, + 118, + 22, + 80, + 213 + ] + }, + { + "key": [ + 148, + 132, + 183, + 206, + 60, + 17, + 138, + 138, + 45, + 85, + 108, + 47, + 123, + 164, + 31, + 202, + 52, + 246, + 12, + 158, + 161, + 7, + 1, + 113, + 69, + 156, + 158, + 116, + 135, + 201, + 83, + 126 + ], + "nonce": [ + 135, + 188, + 3, + 53, + 34, + 174, + 132, + 210, + 171, + 232, + 99, + 197 + ], + "aad": [ + 7, + 238, + 24, + 115, + 123, + 155, + 248, + 34, + 57, + 121, + 160, + 28, + 89, + 169, + 14, + 180 + ], + "plaintext": [ + 20, + 216, + 0, + 71, + 147, + 25, + 5, + 99, + 130, + 94, + 39, + 61, + 218 + ], + "ciphertext": [ + 67, + 3, + 74, + 44, + 87, + 204, + 172, + 195, + 103, + 121, + 109, + 118, + 106 + ], + "tag": [ + 76, + 152, + 28, + 168, + 182, + 233, + 229, + 32, + 146, + 245, + 67, + 94, + 126, + 245, + 95, + 187 + ] + }, + { + "key": [ + 79, + 69, + 57, + 228, + 168, + 14, + 192, + 26, + 20, + 214, + 187, + 27, + 174, + 0, + 16, + 248, + 168, + 179, + 242, + 205, + 10, + 192, + 26, + 223, + 35, + 154, + 155, + 43, + 117, + 95, + 6, + 20 + ], + "nonce": [ + 43, + 111, + 0, + 206, + 21, + 112, + 67, + 43, + 245, + 47, + 220, + 172 + ], + "aad": [ + 13, + 114, + 161, + 62, + 255, + 228, + 5, + 68, + 197, + 124, + 193, + 128, + 5, + 185, + 152, + 203 + ], + "plaintext": [ + 130, + 12, + 201, + 56, + 158, + 126, + 116, + 202, + 28, + 187, + 90, + 95, + 230 + ], + "ciphertext": [ + 153, + 85, + 63, + 223, + 62, + 119, + 126, + 42, + 75, + 59, + 106, + 85, + 56 + ], + "tag": [ + 60, + 191, + 81, + 100, + 10, + 58, + 147, + 195, + 102, + 44, + 115, + 142, + 152, + 251, + 54, + 162 + ] + }, + { + "key": [ + 47, + 94, + 147, + 238, + 36, + 168, + 205, + 47, + 198, + 211, + 118, + 95, + 18, + 210, + 23, + 157, + 219, + 131, + 151, + 120, + 62, + 19, + 106, + 249, + 224, + 172, + 117, + 241, + 111, + 202, + 69, + 30 + ], + "nonce": [ + 13, + 195, + 199, + 10, + 25, + 31, + 55, + 34, + 100, + 31, + 215, + 1 + ], + "aad": [ + 235, + 171, + 48, + 203, + 204, + 153, + 144, + 83, + 84, + 228, + 238, + 111, + 7, + 199, + 219, + 135 + ], + "plaintext": [ + 78, + 150, + 70, + 55, + 147, + 205, + 237, + 164, + 3, + 102, + 140, + 74, + 238 + ], + "ciphertext": [ + 171, + 3, + 248, + 202, + 123, + 27, + 21, + 11, + 220, + 38, + 212, + 230, + 145 + ], + "tag": [ + 2, + 5, + 70, + 175, + 255, + 66, + 144, + 196, + 200, + 239, + 127, + 195, + 128, + 53, + 235, + 253 + ] + }, + { + "key": [ + 169, + 2, + 225, + 93, + 6, + 239, + 90, + 211, + 52, + 208, + 236, + 101, + 2, + 233, + 54, + 238, + 83, + 239, + 63, + 54, + 8, + 247, + 112, + 136, + 72, + 177, + 28, + 239, + 169, + 41, + 131, + 209 + ], + "nonce": [ + 185, + 243, + 233, + 102, + 239, + 164, + 58, + 180, + 172, + 161, + 242, + 216 + ], + "aad": [ + 46, + 170, + 53, + 192, + 11, + 241, + 207, + 138, + 129, + 145, + 155, + 208, + 75, + 67, + 253, + 151 + ], + "plaintext": [ + 57, + 63, + 243, + 223, + 229, + 28, + 212, + 53, + 67, + 228, + 226, + 159, + 204 + ], + "ciphertext": [ + 126, + 137, + 40, + 180, + 80, + 198, + 34, + 172, + 142, + 254, + 41, + 213, + 160 + ], + "tag": [ + 90, + 40, + 93, + 233, + 89, + 144, + 174, + 241, + 113, + 98, + 147, + 80, + 187, + 202, + 244, + 110 + ] + }, + { + "key": [ + 150, + 101, + 121, + 118, + 218, + 118, + 146, + 0, + 78, + 39, + 27, + 89, + 78, + 131, + 4, + 247, + 125, + 185, + 201, + 231, + 120, + 89, + 36, + 107, + 179, + 10, + 22, + 35, + 155, + 167, + 106, + 83 + ], + "nonce": [ + 121, + 34, + 97, + 0, + 175, + 234, + 48, + 100, + 72, + 118, + 231, + 154 + ], + "aad": [ + 237, + 231, + 169, + 7, + 42, + 0, + 134, + 185, + 161, + 229, + 93, + 144, + 7, + 71, + 207, + 118 + ], + "plaintext": [ + 43, + 8, + 51, + 160, + 101, + 195, + 133, + 62, + 226, + 124, + 137, + 104, + 208 + ], + "ciphertext": [ + 25, + 55, + 49, + 104, + 241, + 164, + 5, + 42, + 87, + 198, + 184, + 20, + 111 + ], + "tag": [ + 222, + 187, + 240, + 68, + 50, + 83, + 132, + 185, + 10, + 12, + 68, + 45, + 149, + 69, + 95, + 185 + ] + }, + { + "key": [ + 99, + 14, + 161, + 62, + 181, + 245, + 35, + 120, + 185, + 118, + 186, + 38, + 98, + 248, + 36, + 220, + 98, + 41, + 32, + 117, + 154, + 21, + 210, + 227, + 65, + 196, + 70, + 176, + 62, + 167, + 189, + 92 + ], + "nonce": [ + 15, + 158, + 190, + 71, + 104, + 47, + 147, + 212, + 76, + 77, + 179, + 20 + ], + "aad": [ + 90, + 216, + 233, + 207, + 254, + 98, + 46, + 159, + 53, + 189, + 177, + 133, + 71, + 56, + 104, + 229 + ], + "plaintext": [ + 92, + 115, + 73, + 100, + 135, + 138, + 66, + 80, + 163, + 191, + 97, + 253, + 214 + ], + "ciphertext": [ + 103, + 203, + 109, + 148, + 51, + 64, + 208, + 2, + 211, + 50, + 63, + 204, + 78 + ], + "tag": [ + 245, + 220, + 15, + 136, + 242, + 54, + 86, + 12, + 78, + 42, + 109, + 108, + 21, + 211, + 192, + 222 + ] + }, + { + "key": [ + 198, + 79, + 138, + 58, + 194, + 48, + 220, + 230, + 27, + 83, + 215, + 181, + 132, + 242, + 48, + 147, + 132, + 39, + 77, + 75, + 50, + 212, + 4, + 188, + 12, + 73, + 31, + 18, + 151, + 129, + 229, + 45 + ], + "nonce": [ + 127, + 75, + 59, + 207, + 118, + 63, + 158, + 45, + 8, + 81, + 106, + 109 + ], + "aad": [ + 137, + 237, + 105, + 69, + 84, + 126, + 229, + 153, + 141, + 225, + 187, + 45, + 47, + 11, + 239, + 30 + ], + "plaintext": [ + 254, + 88, + 17, + 40, + 174, + 152, + 50, + 210, + 126, + 197, + 139, + 215, + 172 + ], + "ciphertext": [ + 129, + 215, + 168, + 253, + 175, + 66, + 181, + 113, + 107, + 137, + 33, + 153, + 201 + ], + "tag": [ + 129, + 131, + 170, + 255, + 76, + 9, + 115, + 254, + 86, + 192, + 44, + 46, + 12, + 126, + 68, + 87 + ] + }, + { + "key": [ + 221, + 115, + 103, + 15, + 178, + 33, + 247, + 238, + 24, + 95, + 88, + 24, + 6, + 94, + 34, + 221, + 163, + 120, + 15, + 201, + 0, + 252, + 2, + 239, + 0, + 35, + 44, + 102, + 29, + 123, + 255, + 206 + ], + "nonce": [ + 195, + 61, + 230, + 83, + 68, + 207, + 191, + 34, + 142, + 22, + 82, + 189 + ], + "aad": [ + 225, + 165, + 229, + 36, + 39, + 241, + 197, + 184, + 135, + 87, + 90, + 111, + 44, + 68, + 84, + 41 + ], + "plaintext": [ + 173, + 164, + 217, + 129, + 71, + 179, + 14, + 90, + 144, + 18, + 41, + 149, + 42 + ], + "ciphertext": [ + 110, + 212, + 228, + 189, + 31, + 149, + 61, + 71, + 197, + 40, + 140, + 72, + 244 + ], + "tag": [ + 64, + 78, + 58, + 155, + 159, + 93, + 218, + 185, + 238, + 22, + 154, + 124, + 124, + 44, + 247, + 175 + ] + }, + { + "key": [ + 246, + 197, + 217, + 86, + 43, + 125, + 189, + 208, + 191, + 98, + 141, + 220, + 157, + 102, + 12, + 39, + 132, + 27, + 6, + 166, + 56, + 245, + 102, + 1, + 244, + 8, + 242, + 58, + 162, + 246, + 111, + 78 + ], + "nonce": [ + 103, + 40, + 11, + 203, + 148, + 91, + 166, + 237, + 161, + 198, + 200, + 10 + ], + "aad": [ + 91, + 51, + 113, + 101, + 103, + 182, + 198, + 123, + 120, + 234, + 92, + 217, + 52, + 155, + 202, + 175 + ], + "plaintext": [ + 244, + 202, + 234, + 210, + 66, + 209, + 128, + 251, + 210, + 230, + 211, + 45, + 12 + ], + "ciphertext": [ + 253, + 250, + 57, + 81, + 125, + 137, + 234, + 71, + 230, + 204, + 176, + 248, + 49 + ], + "tag": [ + 145, + 249, + 181, + 64, + 202, + 144, + 227, + 16, + 161, + 245, + 193, + 44, + 3, + 216, + 194, + 94 + ] + }, + { + "key": [ + 206, + 29, + 36, + 47, + 19, + 222, + 118, + 56, + 184, + 112, + 224, + 170, + 133, + 132, + 62, + 164, + 58, + 146, + 85, + 164, + 250, + 77, + 50, + 5, + 115, + 71, + 243, + 142, + 2, + 103, + 218, + 235 + ], + "nonce": [ + 134, + 86, + 43, + 228, + 98, + 27, + 77, + 94, + 177, + 152, + 48, + 117 + ], + "aad": [ + 212, + 138, + 148, + 144, + 160, + 183, + 222, + 176, + 35, + 70, + 6, + 8, + 183, + 219, + 121, + 206 + ], + "plaintext": [ + 210, + 14, + 89, + 168, + 239, + 26, + 125, + 233, + 9, + 108, + 62, + 103, + 70 + ], + "ciphertext": [ + 53, + 206, + 105, + 251, + 21, + 208, + 17, + 89, + 197, + 34, + 102, + 83, + 124 + ], + "tag": [ + 220, + 72, + 247, + 184, + 211, + 254, + 238, + 178, + 111, + 207, + 99, + 192, + 210, + 168, + 137, + 236 + ] + }, + { + "key": [ + 81, + 39, + 83, + 206, + 167, + 200, + 166, + 22, + 95, + 46, + 187, + 211, + 118, + 140, + 199, + 185, + 81, + 2, + 155, + 213, + 39, + 177, + 38, + 35, + 60, + 240, + 132, + 26, + 255, + 117, + 104, + 199 + ], + "nonce": [ + 183, + 146, + 33, + 128, + 45, + 141, + 151, + 151, + 128, + 65, + 254, + 132 + ], + "aad": [ + 34, + 250, + 6, + 5, + 185, + 85, + 163, + 52, + 104, + 243, + 230, + 1, + 96, + 185, + 7, + 242 + ], + "plaintext": [ + 198, + 61, + 108, + 16, + 6, + 182, + 21, + 39, + 92, + 8, + 87, + 48, + 177 + ], + "ciphertext": [ + 189, + 181, + 215, + 242, + 71, + 50, + 189, + 186, + 29, + 42, + 66, + 145, + 8 + ], + "tag": [ + 252, + 169, + 35, + 210, + 148, + 26, + 111, + 217, + 213, + 150, + 184, + 108, + 58, + 251, + 10, + 217 + ] + }, + { + "key": [ + 231, + 177, + 132, + 41, + 227, + 237, + 222, + 210, + 217, + 146, + 202, + 39, + 175, + 171, + 153, + 228, + 56, + 184, + 175, + 242, + 95, + 200, + 70, + 2, + 1, + 250, + 190, + 8, + 231, + 212, + 142, + 194 + ], + "nonce": [ + 157, + 185, + 183, + 50, + 10, + 170, + 198, + 133, + 56, + 227, + 123, + 247 + ], + "aad": [ + 40, + 62, + 18, + 162, + 110, + 22, + 70, + 8, + 123, + 91, + 157, + 140, + 18, + 61, + 222, + 31 + ], + "plaintext": [ + 196, + 113, + 59, + 198, + 122, + 89, + 146, + 142, + 238, + 80, + 3, + 153, + 1 + ], + "ciphertext": [ + 165, + 147, + 47, + 146, + 189, + 161, + 7, + 210, + 143, + 42, + 138, + 170, + 116 + ], + "tag": [ + 154, + 19, + 87, + 253, + 142, + 210, + 31, + 225, + 77, + 28, + 162, + 229, + 151, + 195, + 239, + 23 + ] + }, + { + "key": [ + 105, + 180, + 88, + 242, + 100, + 74, + 249, + 2, + 4, + 99, + 180, + 14, + 229, + 3, + 205, + 240, + 131, + 214, + 147, + 129, + 94, + 38, + 89, + 5, + 26, + 224, + 208, + 57, + 230, + 6, + 169, + 112 + ], + "nonce": [ + 141, + 29, + 168, + 171, + 95, + 145, + 204, + 208, + 146, + 5, + 148, + 75 + ], + "aad": [ + 3, + 106, + 213, + 229, + 73, + 78, + 248, + 23, + 168, + 175, + 47, + 88, + 40, + 120, + 74, + 75, + 254, + 221, + 22, + 83 + ], + "plaintext": [ + 243, + 224, + 224, + 146, + 36, + 37, + 107, + 242, + 26, + 131, + 165, + 222, + 141 + ], + "ciphertext": [ + 192, + 166, + 45, + 119, + 230, + 3, + 27, + 253, + 198, + 177, + 58, + 226, + 23 + ], + "tag": [ + 167, + 148, + 169, + 170, + 238, + 72, + 205, + 146, + 228, + 119, + 97, + 191, + 27, + 175, + 240, + 175 + ] + }, + { + "key": [ + 151, + 67, + 30, + 86, + 94, + 131, + 112, + 164, + 135, + 157, + 233, + 98, + 116, + 106, + 47, + 214, + 126, + 202, + 134, + 139, + 28, + 142, + 81, + 238, + 206, + 44, + 31, + 148, + 247, + 74, + 244, + 7 + ], + "nonce": [ + 23, + 251, + 99, + 6, + 110, + 39, + 38, + 210, + 130, + 236, + 198, + 16 + ], + "aad": [ + 120, + 231, + 55, + 77, + 167, + 199, + 123, + 229, + 147, + 141, + 232, + 221, + 118, + 207, + 3, + 8, + 97, + 131, + 6, + 169 + ], + "plaintext": [ + 226, + 22, + 41, + 204, + 151, + 63, + 190, + 64, + 23, + 110, + 98, + 29, + 157 + ], + "ciphertext": [ + 128, + 219, + 212, + 105, + 222, + 72, + 3, + 137, + 186, + 108, + 47, + 202, + 82 + ], + "tag": [ + 78, + 40, + 74, + 187, + 139, + 79, + 159, + 19, + 199, + 73, + 122, + 229, + 109, + 240, + 95, + 165 + ] + }, + { + "key": [ + 43, + 20, + 173, + 104, + 244, + 66, + 247, + 249, + 42, + 114, + 199, + 186, + 144, + 155, + 207, + 153, + 92, + 130, + 123, + 67, + 157, + 57, + 160, + 47, + 119, + 201, + 191, + 143, + 132, + 171, + 4, + 220 + ], + "nonce": [ + 76, + 132, + 126, + 165, + 159, + 131, + 216, + 43, + 10, + 192, + 188, + 55 + ], + "aad": [ + 142, + 182, + 80, + 246, + 98, + 190, + 35, + 25, + 30, + 136, + 241, + 205, + 4, + 34, + 229, + 116, + 83, + 9, + 14, + 33 + ], + "plaintext": [ + 179, + 196, + 178, + 110, + 187, + 252, + 113, + 127, + 81, + 232, + 116, + 88, + 125 + ], + "ciphertext": [ + 62, + 40, + 132, + 120, + 104, + 142, + 96, + 23, + 137, + 32, + 9, + 8, + 20 + ], + "tag": [ + 169, + 40, + 220, + 2, + 105, + 134, + 130, + 48, + 98, + 243, + 126, + 200, + 37, + 198, + 123, + 149 + ] + }, + { + "key": [ + 17, + 244, + 27, + 247, + 212, + 185, + 172, + 123, + 0, + 53, + 206, + 84, + 72, + 30, + 209, + 80, + 47, + 240, + 92, + 250, + 224, + 47, + 251, + 169, + 229, + 2, + 246, + 27, + 254, + 120, + 83, + 81 + ], + "nonce": [ + 6, + 245, + 207, + 140, + 18, + 194, + 54, + 224, + 148, + 195, + 32, + 20 + ], + "aad": [ + 209, + 92, + 189, + 230, + 41, + 11, + 119, + 35, + 98, + 92, + 153, + 255, + 168, + 42, + 156, + 76, + 3, + 237, + 33, + 77 + ], + "plaintext": [ + 190, + 227, + 116, + 163, + 34, + 147, + 202, + 213, + 225, + 178, + 132, + 25, + 179 + ], + "ciphertext": [ + 63, + 129, + 34, + 222, + 182, + 219, + 224, + 255, + 89, + 100, + 65, + 32, + 61 + ], + "tag": [ + 96, + 239, + 127, + 55, + 35, + 113, + 11, + 154, + 183, + 68, + 248, + 238, + 160, + 2, + 103, + 247 + ] + }, + { + "key": [ + 24, + 202, + 87, + 45, + 160, + 85, + 162, + 235, + 180, + 121, + 190, + 109, + 109, + 113, + 100, + 231, + 143, + 89, + 43, + 21, + 156, + 222, + 167, + 110, + 159, + 226, + 8, + 6, + 45, + 123, + 63, + 161 + ], + "nonce": [ + 27, + 4, + 30, + 83, + 74, + 226, + 7, + 72, + 38, + 47, + 57, + 41 + ], + "aad": [ + 232, + 169, + 37, + 215, + 206, + 24, + 221, + 69, + 107, + 7, + 28, + 180, + 196, + 102, + 85, + 148, + 14, + 251, + 233, + 145 + ], + "plaintext": [ + 205, + 162, + 250, + 0, + 21, + 54, + 30, + 207, + 104, + 76, + 107, + 167, + 209 + ], + "ciphertext": [ + 116, + 13, + 141, + 87, + 142, + 46, + 117, + 34, + 195, + 16, + 25, + 244, + 113 + ], + "tag": [ + 242, + 238, + 181, + 175, + 27, + 254, + 221, + 16, + 87, + 10, + 19, + 127, + 226, + 86, + 108, + 63 + ] + }, + { + "key": [ + 13, + 226, + 172, + 91, + 254, + 201, + 232, + 168, + 89, + 195, + 182, + 184, + 109, + 222, + 5, + 55, + 2, + 156, + 220, + 162, + 208, + 132, + 75, + 243, + 225, + 217, + 143, + 55, + 14, + 25, + 155, + 225 + ], + "nonce": [ + 23, + 120, + 227, + 8, + 224, + 34, + 18, + 136, + 241, + 235, + 76, + 90 + ], + "aad": [ + 19, + 98, + 38, + 79, + 86, + 85, + 247, + 25, + 134, + 170, + 120, + 142, + 253, + 72, + 246, + 252, + 19, + 187, + 106, + 180 + ], + "plaintext": [ + 87, + 93, + 147, + 163, + 65, + 103, + 99, + 203, + 211, + 113, + 181, + 166, + 113 + ], + "ciphertext": [ + 143, + 141, + 247, + 202, + 131, + 191, + 135, + 107, + 99, + 199, + 142, + 44, + 154 + ], + "tag": [ + 22, + 199, + 78, + 49, + 90, + 171, + 151, + 239, + 175, + 190, + 149, + 201, + 220, + 170, + 45, + 12 + ] + }, + { + "key": [ + 179, + 129, + 83, + 90, + 8, + 91, + 196, + 128, + 143, + 167, + 161, + 57, + 199, + 32, + 78, + 138, + 135, + 199, + 20, + 93, + 252, + 143, + 57, + 0, + 223, + 31, + 169, + 169, + 132, + 79, + 171, + 53 + ], + "nonce": [ + 33, + 221, + 197, + 77, + 60, + 99, + 63, + 74, + 52, + 74, + 14, + 66 + ], + "aad": [ + 122, + 195, + 186, + 96, + 14, + 8, + 54, + 61, + 219, + 87, + 196, + 90, + 134, + 112, + 187, + 74, + 187, + 134, + 157, + 176 + ], + "plaintext": [ + 228, + 217, + 88, + 206, + 229, + 131, + 1, + 11, + 191, + 211, + 165, + 48, + 33 + ], + "ciphertext": [ + 196, + 44, + 129, + 163, + 18, + 117, + 156, + 219, + 3, + 42, + 175, + 232, + 82 + ], + "tag": [ + 12, + 71, + 37, + 145, + 219, + 61, + 248, + 167, + 198, + 113, + 100, + 89, + 21, + 66, + 220, + 201 + ] + }, + { + "key": [ + 41, + 242, + 30, + 80, + 41, + 234, + 73, + 100, + 185, + 109, + 198, + 244, + 195, + 75, + 45, + 244, + 204, + 224, + 47, + 47, + 207, + 15, + 22, + 143, + 253, + 71, + 14, + 120, + 88, + 224, + 160, + 173 + ], + "nonce": [ + 99, + 161, + 193, + 204, + 195, + 40, + 40, + 10, + 144, + 255, + 150, + 254 + ], + "aad": [ + 69, + 79, + 68, + 116, + 51, + 240, + 148, + 133, + 129, + 149, + 108, + 75, + 225, + 177, + 157, + 147, + 46, + 137, + 180, + 146 + ], + "plaintext": [ + 220, + 18, + 17, + 55, + 100, + 193, + 60, + 33, + 67, + 44, + 161, + 186, + 51 + ], + "ciphertext": [ + 28, + 180, + 90, + 172, + 93, + 239, + 147, + 218, + 239, + 128, + 107, + 120, + 30 + ], + "tag": [ + 244, + 176, + 114, + 60, + 137, + 96, + 123, + 102, + 195, + 146, + 4, + 155, + 160, + 66, + 219, + 99 + ] + }, + { + "key": [ + 39, + 51, + 211, + 170, + 82, + 169, + 215, + 10, + 159, + 189, + 108, + 226, + 54, + 75, + 181, + 249, + 0, + 73, + 2, + 170, + 94, + 235, + 23, + 68, + 110, + 8, + 242, + 189, + 204, + 65, + 219, + 21 + ], + "nonce": [ + 25, + 108, + 74, + 221, + 184, + 74, + 88, + 190, + 179, + 103, + 74, + 122 + ], + "aad": [ + 201, + 130, + 111, + 227, + 31, + 41, + 181, + 91, + 157, + 15, + 157, + 169, + 121, + 88, + 105, + 161, + 169, + 139, + 239, + 229 + ], + "plaintext": [ + 203, + 197, + 12, + 175, + 218, + 37, + 68, + 188, + 210, + 145, + 232, + 160, + 37 + ], + "ciphertext": [ + 122, + 137, + 204, + 88, + 204, + 185, + 122, + 211, + 229, + 76, + 164, + 169, + 200 + ], + "tag": [ + 57, + 144, + 217, + 171, + 162, + 16, + 24, + 41, + 150, + 253, + 189, + 145, + 194, + 174, + 72, + 1 + ] + }, + { + "key": [ + 12, + 75, + 144, + 5, + 180, + 7, + 65, + 92, + 25, + 103, + 43, + 205, + 14, + 190, + 22, + 159, + 102, + 254, + 64, + 79, + 34, + 82, + 155, + 175, + 85, + 86, + 142, + 9, + 1, + 233, + 73, + 34 + ], + "nonce": [ + 229, + 19, + 129, + 233, + 89, + 161, + 245, + 104, + 140, + 147, + 133, + 118 + ], + "aad": [ + 11, + 81, + 47, + 174, + 180, + 218, + 116, + 13, + 204, + 30, + 48, + 211, + 199, + 234, + 97, + 3, + 94, + 133, + 112, + 183 + ], + "plaintext": [ + 198, + 23, + 155, + 211, + 69, + 29, + 146, + 153, + 183, + 39, + 232, + 189, + 10 + ], + "ciphertext": [ + 77, + 63, + 224, + 134, + 201, + 144, + 241, + 96, + 32, + 180, + 197, + 238, + 214 + ], + "tag": [ + 159, + 242, + 41, + 120, + 69, + 129, + 71, + 25, + 248, + 81, + 171, + 9, + 67, + 17, + 126, + 251 + ] + }, + { + "key": [ + 254, + 228, + 66, + 186, + 55, + 195, + 81, + 236, + 9, + 74, + 72, + 121, + 66, + 22, + 165, + 29, + 32, + 140, + 106, + 91, + 160, + 229, + 189, + 184, + 243, + 192, + 240, + 223, + 193, + 228, + 237, + 99 + ], + "nonce": [ + 166, + 102, + 242, + 240, + 212, + 34, + 20, + 219, + 170, + 106, + 38, + 88 + ], + "aad": [ + 113, + 152, + 193, + 40, + 16, + 52, + 84, + 3, + 134, + 44, + 83, + 116, + 9, + 44, + 199, + 155, + 102, + 155, + 174, + 204 + ], + "plaintext": [ + 162, + 207, + 62, + 160, + 228, + 62, + 67, + 82, + 97, + 203, + 102, + 58, + 59 + ], + "ciphertext": [ + 113, + 61, + 64, + 80, + 248, + 199, + 253, + 99, + 192, + 193, + 191, + 42, + 217 + ], + "tag": [ + 37, + 10, + 53, + 226, + 180, + 91, + 166, + 176, + 254, + 36, + 81, + 47, + 130, + 19, + 216, + 203 + ] + }, + { + "key": [ + 119, + 247, + 84, + 208, + 207, + 125, + 189, + 175, + 117, + 207, + 233, + 101, + 171, + 19, + 30, + 140, + 211, + 144, + 135, + 238, + 109, + 152, + 109, + 236, + 74, + 210, + 255, + 8, + 235, + 215, + 241, + 75 + ], + "nonce": [ + 226, + 138, + 20, + 243, + 16, + 124, + 161, + 144, + 216, + 36, + 237, + 95 + ], + "aad": [ + 29, + 236, + 240, + 203, + 197, + 10, + 157, + 166, + 218, + 212, + 167, + 133, + 169, + 65, + 228, + 185, + 92, + 229, + 170, + 168 + ], + "plaintext": [ + 84, + 169, + 122, + 116, + 136, + 158, + 85, + 216, + 4, + 52, + 81, + 199, + 150 + ], + "ciphertext": [ + 238, + 219, + 248, + 221, + 129, + 235, + 25, + 24, + 69, + 137, + 220, + 177, + 87 + ], + "tag": [ + 119, + 73, + 237, + 215, + 82, + 250, + 183, + 229, + 13, + 188, + 59, + 11, + 71, + 103, + 139, + 246 + ] + }, + { + "key": [ + 5, + 35, + 242, + 50, + 0, + 30, + 104, + 189, + 101, + 167, + 152, + 55, + 187, + 175, + 112, + 236, + 46, + 32, + 133, + 19, + 1, + 216, + 225, + 47, + 221, + 181, + 146, + 106, + 203, + 33, + 0, + 203 + ], + "nonce": [ + 43, + 184, + 213, + 203, + 60, + 235, + 21, + 16, + 117, + 130, + 225, + 250 + ], + "aad": [ + 31, + 85, + 187, + 167, + 28, + 182, + 61, + 244, + 49, + 239, + 136, + 50, + 199, + 116, + 153, + 238, + 60, + 80, + 32, + 103 + ], + "plaintext": [ + 107, + 76, + 220, + 159, + 156, + 80, + 130, + 216, + 106, + 29, + 46, + 104, + 254 + ], + "ciphertext": [ + 7, + 159, + 233, + 14, + 245, + 23, + 237, + 47, + 97, + 74, + 60, + 216, + 206 + ], + "tag": [ + 83, + 156, + 48, + 89, + 10, + 37, + 39, + 241, + 213, + 45, + 250, + 233, + 41, + 32, + 121, + 76 + ] + }, + { + "key": [ + 84, + 197, + 110, + 232, + 105, + 235, + 177, + 18, + 164, + 8, + 113, + 126, + 180, + 10, + 246, + 147, + 127, + 229, + 30, + 176, + 97, + 180, + 34, + 119, + 161, + 5, + 55, + 231, + 219, + 52, + 107, + 106 + ], + "nonce": [ + 91, + 251, + 99, + 226, + 243, + 229, + 178, + 225, + 180, + 52, + 52, + 128 + ], + "aad": [ + 116, + 10, + 176, + 123, + 156, + 93, + 226, + 175, + 163, + 127, + 7, + 136, + 174, + 82, + 48, + 83, + 92, + 24, + 32, + 61 + ], + "plaintext": [ + 117, + 249, + 73, + 107, + 141, + 12, + 169, + 110, + 211, + 175, + 2, + 220, + 171 + ], + "ciphertext": [ + 130, + 121, + 2, + 229, + 140, + 76, + 139, + 122, + 249, + 118, + 246, + 24, + 66 + ], + "tag": [ + 3, + 110, + 230, + 71, + 60, + 33, + 56, + 242, + 162, + 194, + 132, + 20, + 56, + 203, + 14, + 220 + ] + }, + { + "key": [ + 217, + 104, + 255, + 219, + 237, + 111, + 252, + 37, + 155, + 67, + 16, + 226, + 233, + 126, + 66, + 216, + 119, + 239, + 93, + 134, + 210, + 22, + 153, + 40, + 197, + 16, + 49, + 152, + 55, + 121, + 164, + 133 + ], + "nonce": [ + 99, + 61, + 13, + 141, + 54, + 19, + 200, + 59, + 64, + 223, + 153, + 221 + ], + "aad": [ + 154, + 173, + 200, + 216, + 151, + 94, + 192, + 163, + 245, + 201, + 96, + 206, + 114, + 170, + 236, + 142, + 240, + 180, + 32, + 52 + ], + "plaintext": [ + 8, + 207, + 198, + 95, + 234, + 155, + 7, + 240, + 192, + 29, + 41, + 223, + 223 + ], + "ciphertext": [ + 123, + 69, + 15, + 22, + 43, + 222, + 220, + 48, + 27, + 150, + 163, + 172, + 54 + ], + "tag": [ + 151, + 13, + 151, + 52, + 75, + 20, + 81, + 243, + 249, + 105, + 174, + 185, + 114, + 211, + 82, + 230 + ] + }, + { + "key": [ + 95, + 103, + 20, + 102, + 55, + 143, + 71, + 11, + 165, + 245, + 22, + 14, + 34, + 9, + 243, + 217, + 90, + 72, + 183, + 229, + 96, + 98, + 93, + 90, + 8, + 101, + 68, + 20, + 222, + 35, + 174, + 226 + ], + "nonce": [ + 107, + 60, + 8, + 166, + 99, + 208, + 65, + 50, + 36, + 61, + 217, + 108 + ], + "aad": [ + 18, + 150, + 85, + 89, + 195, + 29, + 83, + 143, + 147, + 123, + 218, + 110, + 238, + 156, + 147, + 176, + 56, + 115, + 24, + 220, + 93, + 148, + 150, + 251, + 28, + 58, + 11, + 155, + 151, + 141, + 191, + 235, + 255, + 42, + 88, + 35, + 151, + 78, + 233, + 214, + 121, + 131, + 77, + 190, + 89, + 247, + 236, + 81 + ], + "plaintext": [ + 196, + 40, + 89, + 45, + 159, + 138, + 127, + 16, + 126, + 196, + 208, + 223, + 5 + ], + "ciphertext": [ + 29, + 141, + 127, + 228, + 53, + 112, + 128, + 200, + 23, + 48, + 60, + 225, + 156 + ], + "tag": [ + 232, + 141, + 107, + 86, + 111, + 220, + 123, + 79, + 214, + 33, + 6, + 189, + 46, + 184, + 6, + 236 + ] + }, + { + "key": [ + 251, + 204, + 46, + 127, + 170, + 66, + 149, + 8, + 14, + 64, + 177, + 65, + 190, + 248, + 41, + 186, + 157, + 52, + 224, + 105, + 18, + 49, + 173, + 108, + 98, + 181, + 16, + 144, + 9, + 215, + 75, + 94 + ], + "nonce": [ + 127, + 53, + 217, + 236, + 101, + 28, + 91, + 9, + 102, + 87, + 62, + 47 + ], + "aad": [ + 99, + 48, + 209, + 96, + 2, + 168, + 253, + 81, + 118, + 32, + 67, + 242, + 223, + 6, + 236, + 201, + 197, + 53, + 201, + 110, + 190, + 51, + 82, + 109, + 143, + 175, + 118, + 124, + 44, + 42, + 243, + 205, + 1, + 244, + 224, + 47, + 161, + 2, + 241, + 92, + 224, + 35, + 109, + 156, + 156, + 239, + 38, + 222 + ], + "plaintext": [ + 205, + 210, + 81, + 212, + 73, + 85, + 31, + 236, + 8, + 4, + 37, + 213, + 101 + ], + "ciphertext": [ + 81, + 76, + 85, + 35, + 2, + 77, + 212, + 199, + 213, + 155, + 215, + 59, + 21 + ], + "tag": [ + 211, + 163, + 153, + 132, + 62, + 87, + 118, + 170, + 52, + 142, + 62, + 94, + 86, + 72, + 47, + 255 + ] + }, + { + "key": [ + 4, + 239, + 102, + 14, + 192, + 65, + 245, + 192, + 194, + 66, + 9, + 249, + 89, + 204, + 241, + 162, + 167, + 205, + 176, + 219, + 162, + 43, + 19, + 78, + 169, + 247, + 94, + 111, + 30, + 253, + 174, + 74 + ], + "nonce": [ + 15, + 95, + 111, + 188, + 162, + 147, + 88, + 33, + 124, + 138, + 107, + 103 + ], + "aad": [ + 80, + 94, + 32, + 93, + 19, + 236, + 148, + 83, + 145, + 199, + 214, + 81, + 106, + 248, + 98, + 85, + 232, + 47, + 56, + 67, + 63, + 64, + 64, + 77, + 79, + 30, + 66, + 210, + 59, + 51, + 235, + 158, + 109, + 234, + 88, + 32, + 218, + 214, + 6, + 34, + 211, + 168, + 37, + 252, + 143, + 1, + 165, + 210 + ], + "plaintext": [ + 8, + 53, + 179, + 18, + 25, + 31, + 48, + 249, + 49, + 230, + 90, + 160, + 95 + ], + "ciphertext": [ + 93, + 220, + 15, + 89, + 99, + 240, + 41, + 12, + 26, + 15, + 182, + 91, + 231 + ], + "tag": [ + 16, + 109, + 31, + 141, + 38, + 171, + 228, + 180, + 177, + 229, + 144, + 205, + 93, + 133, + 231, + 55 + ] + }, + { + "key": [ + 66, + 211, + 255, + 116, + 40, + 67, + 149, + 251, + 157, + 185, + 184, + 199, + 164, + 68, + 250, + 64, + 15, + 127, + 198, + 185, + 133, + 167, + 254, + 194, + 71, + 134, + 103, + 199, + 241, + 124, + 243, + 186 + ], + "nonce": [ + 137, + 35, + 15, + 190, + 213, + 157, + 18, + 38, + 160, + 147, + 173, + 40 + ], + "aad": [ + 96, + 52, + 47, + 151, + 49, + 4, + 70, + 38, + 107, + 46, + 71, + 177, + 142, + 0, + 137, + 121, + 208, + 127, + 193, + 129, + 21, + 26, + 192, + 147, + 155, + 73, + 94, + 127, + 49, + 222, + 29, + 14, + 116, + 4, + 37, + 50, + 132, + 10, + 185, + 22, + 134, + 239, + 215, + 164, + 2, + 210, + 122, + 148 + ], + "plaintext": [ + 216, + 51, + 158, + 54, + 24, + 186, + 87, + 162, + 67, + 162, + 124, + 133, + 214 + ], + "ciphertext": [ + 155, + 182, + 250, + 54, + 250, + 22, + 112, + 22, + 16, + 157, + 82, + 26, + 192 + ], + "tag": [ + 96, + 9, + 9, + 239, + 50, + 202, + 98, + 149, + 30, + 203, + 220, + 129, + 28, + 170, + 119, + 120 + ] + }, + { + "key": [ + 225, + 21, + 198, + 70, + 134, + 6, + 165, + 249, + 184, + 233, + 167, + 194, + 32, + 215, + 215, + 104, + 77, + 104, + 108, + 146, + 16, + 166, + 105, + 119, + 11, + 110, + 75, + 242, + 68, + 71, + 205, + 23 + ], + "nonce": [ + 2, + 156, + 124, + 158, + 226, + 211, + 171, + 38, + 132, + 62, + 139, + 65 + ], + "aad": [ + 27, + 239, + 217, + 249, + 127, + 153, + 252, + 9, + 109, + 234, + 253, + 229, + 225, + 88, + 172, + 134, + 113, + 108, + 11, + 163, + 36, + 84, + 152, + 143, + 228, + 139, + 164, + 115, + 118, + 132, + 54, + 24, + 73, + 162, + 33, + 192, + 63, + 192, + 148, + 140, + 178, + 91, + 95, + 41, + 214, + 160, + 203, + 42 + ], + "plaintext": [ + 122, + 191, + 132, + 132, + 47, + 152, + 103, + 207, + 197, + 234, + 188, + 112, + 50 + ], + "ciphertext": [ + 133, + 28, + 112, + 71, + 251, + 9, + 100, + 111, + 189, + 219, + 130, + 69, + 49 + ], + "tag": [ + 208, + 172, + 65, + 16, + 200, + 215, + 104, + 240, + 168, + 4, + 236, + 218, + 56, + 124, + 250, + 48 + ] + }, + { + "key": [ + 86, + 85, + 47, + 12, + 239, + 52, + 103, + 58, + 76, + 149, + 143, + 245, + 90, + 208, + 179, + 44, + 106, + 186, + 186, + 6, + 203, + 58, + 233, + 1, + 120, + 171, + 28, + 154, + 31, + 41, + 192, + 229 + ], + "nonce": [ + 179, + 77, + 36, + 147, + 84, + 7, + 232, + 89, + 34, + 71, + 255, + 255 + ], + "aad": [ + 177, + 153, + 67, + 125, + 161, + 137, + 72, + 106, + 143, + 209, + 194, + 250, + 31, + 227, + 235, + 187, + 17, + 111, + 14, + 244, + 20, + 21, + 187, + 124, + 128, + 101, + 39, + 47, + 176, + 178, + 254, + 142, + 220, + 169, + 205, + 13, + 66, + 85, + 212, + 103, + 231, + 127, + 40, + 52, + 190, + 85, + 116, + 116 + ], + "plaintext": [ + 219, + 214, + 204, + 53, + 139, + 40, + 171, + 102, + 166, + 159, + 82, + 56, + 212 + ], + "ciphertext": [ + 118, + 220, + 141, + 3, + 94, + 92, + 164, + 0, + 30, + 78, + 63, + 203, + 24 + ], + "tag": [ + 73, + 192, + 31, + 115, + 93, + 161, + 19, + 28, + 212, + 43, + 1, + 183, + 70, + 253, + 56, + 222 + ] + }, + { + "key": [ + 212, + 244, + 5, + 186, + 85, + 110, + 111, + 231, + 75, + 126, + 109, + 189, + 215, + 168, + 234, + 227, + 99, + 118, + 209, + 202, + 122, + 152, + 213, + 103, + 209, + 8, + 114, + 154, + 234, + 229, + 195, + 38 + ], + "nonce": [ + 223, + 102, + 55, + 201, + 138, + 101, + 146, + 132, + 62, + 11, + 129, + 239 + ], + "aad": [ + 165, + 50, + 140, + 186, + 189, + 254, + 108, + 60, + 29, + 79, + 81, + 82, + 24, + 144, + 114, + 218, + 222, + 113, + 226, + 186, + 205, + 133, + 125, + 60, + 227, + 126, + 233, + 227, + 22, + 30, + 176, + 242, + 13, + 229, + 162, + 155, + 121, + 153, + 253, + 156, + 124, + 96, + 205, + 192, + 55, + 81, + 189, + 27 + ], + "plaintext": [ + 171, + 232, + 118, + 65, + 233, + 165, + 22, + 159, + 144, + 23, + 157, + 48, + 153 + ], + "ciphertext": [ + 6, + 249, + 207, + 150, + 119, + 116, + 94, + 120, + 198, + 192, + 43, + 240, + 107 + ], + "tag": [ + 90, + 58, + 118, + 218, + 7, + 3, + 194, + 74, + 149, + 136, + 175, + 178, + 172, + 26, + 158, + 19 + ] + }, + { + "key": [ + 79, + 102, + 127, + 101, + 234, + 69, + 105, + 38, + 68, + 86, + 226, + 93, + 228, + 152, + 87, + 144, + 54, + 214, + 166, + 4, + 193, + 139, + 175, + 119, + 11, + 182, + 38, + 216, + 161, + 198, + 142, + 79 + ], + "nonce": [ + 67, + 226, + 125, + 39, + 90, + 190, + 253, + 212, + 81, + 55, + 200, + 255 + ], + "aad": [ + 38, + 75, + 128, + 123, + 70, + 49, + 215, + 200, + 126, + 233, + 241, + 80, + 112, + 130, + 245, + 175, + 146, + 24, + 245, + 49, + 180, + 99, + 1, + 65, + 243, + 201, + 73, + 57, + 170, + 124, + 248, + 28, + 113, + 234, + 84, + 7, + 131, + 153, + 85, + 96, + 191, + 126, + 110, + 2, + 209, + 150, + 34, + 127 + ], + "plaintext": [ + 234, + 162, + 73, + 140, + 226, + 126, + 86, + 88, + 72, + 147, + 129, + 182, + 236 + ], + "ciphertext": [ + 186, + 192, + 24, + 191, + 46, + 112, + 144, + 231, + 242, + 23, + 171, + 51, + 101 + ], + "tag": [ + 19, + 229, + 161, + 106, + 156, + 231, + 168, + 140, + 218, + 100, + 13, + 226, + 196, + 253, + 192, + 126 + ] + }, + { + "key": [ + 245, + 98, + 74, + 22, + 103, + 89, + 239, + 11, + 129, + 104, + 175, + 101, + 101, + 100, + 159, + 119, + 151, + 250, + 146, + 71, + 110, + 0, + 140, + 64, + 116, + 88, + 16, + 30, + 117, + 131, + 19, + 18 + ], + "nonce": [ + 82, + 28, + 167, + 159, + 252, + 137, + 48, + 52, + 154, + 191, + 192, + 82 + ], + "aad": [ + 110, + 39, + 113, + 236, + 214, + 55, + 54, + 28, + 182, + 185, + 71, + 20, + 137, + 16, + 247, + 217, + 32, + 109, + 106, + 241, + 118, + 197, + 16, + 187, + 93, + 213, + 188, + 155, + 151, + 172, + 1, + 95, + 176, + 85, + 55, + 175, + 251, + 193, + 117, + 102, + 37, + 113, + 83, + 116, + 23, + 47, + 180, + 86 + ], + "plaintext": [ + 31, + 171, + 61, + 239, + 46, + 161, + 62, + 129, + 95, + 135, + 70, + 9, + 59 + ], + "ciphertext": [ + 202, + 114, + 255, + 21, + 167, + 235, + 98, + 162, + 131, + 155, + 207, + 12, + 67 + ], + "tag": [ + 71, + 95, + 255, + 109, + 158, + 35, + 130, + 88, + 60, + 150, + 20, + 2, + 8, + 68, + 185, + 42 + ] + }, + { + "key": [ + 172, + 19, + 131, + 163, + 199, + 131, + 211, + 208, + 102, + 126, + 148, + 76, + 190, + 26, + 97, + 89, + 100, + 123, + 150, + 175, + 169, + 34, + 85, + 126, + 177, + 203, + 100, + 7, + 84, + 107, + 152, + 202 + ], + "nonce": [ + 112, + 54, + 97, + 18, + 219, + 225, + 189, + 144, + 91, + 144, + 14, + 58 + ], + "aad": [ + 183, + 193, + 134, + 89, + 39, + 115, + 123, + 238, + 128, + 36, + 21, + 39, + 124, + 241, + 162, + 91, + 115, + 128, + 119, + 74, + 157, + 39, + 182, + 163, + 37, + 63, + 7, + 125, + 54, + 233, + 196, + 20, + 45, + 242, + 187, + 191, + 60, + 3, + 65, + 74, + 192, + 145, + 97, + 98, + 108, + 233, + 54, + 124 + ], + "plaintext": [ + 184, + 221, + 135, + 31, + 157, + 134, + 104, + 103, + 239, + 190, + 85, + 28, + 59 + ], + "ciphertext": [ + 186, + 24, + 24, + 116, + 56, + 8, + 65, + 121, + 31, + 100, + 136, + 21, + 52 + ], + "tag": [ + 197, + 100, + 30, + 223, + 66, + 196, + 70, + 135, + 51, + 114, + 187, + 189, + 225, + 20, + 102, + 66 + ] + }, + { + "key": [ + 243, + 116, + 153, + 217, + 182, + 173, + 46, + 118, + 24, + 227, + 10, + 35, + 8, + 38, + 115, + 0, + 143, + 58, + 225, + 147, + 139, + 147, + 151, + 192, + 42, + 77, + 162, + 69, + 63, + 183, + 228, + 3 + ], + "nonce": [ + 24, + 225, + 18, + 234, + 106, + 153, + 141, + 111, + 151, + 5, + 247, + 224 + ], + "aad": [ + 115, + 111, + 26, + 113, + 251, + 37, + 159, + 70, + 198, + 81, + 155, + 184, + 116, + 81, + 242, + 56, + 244, + 125, + 128, + 199, + 74, + 1, + 102, + 4, + 73, + 155, + 2, + 86, + 143, + 28, + 123, + 237, + 247, + 15, + 149, + 151, + 215, + 182, + 44, + 22, + 152, + 196, + 242, + 99, + 31, + 78, + 151, + 6 + ], + "plaintext": [ + 49, + 86, + 11, + 33, + 20, + 162, + 72, + 255, + 224, + 105, + 111, + 161, + 48 + ], + "ciphertext": [ + 1, + 99, + 245, + 88, + 190, + 1, + 66, + 235, + 171, + 222, + 41, + 167, + 188 + ], + "tag": [ + 69, + 87, + 156, + 224, + 126, + 230, + 76, + 218, + 195, + 167, + 164, + 33, + 9, + 255, + 68, + 231 + ] + }, + { + "key": [ + 80, + 183, + 245, + 17, + 142, + 247, + 238, + 34, + 177, + 7, + 217, + 60, + 234, + 185, + 136, + 30, + 249, + 101, + 137, + 49, + 232, + 3, + 133, + 209, + 174, + 146, + 80, + 27, + 149, + 228, + 125, + 98 + ], + "nonce": [ + 213, + 17, + 54, + 101, + 3, + 145, + 105, + 151, + 139, + 125, + 196, + 219 + ], + "aad": [ + 104, + 255, + 108, + 99, + 233, + 76, + 183, + 221, + 43, + 132, + 19, + 102, + 42, + 86, + 200, + 141, + 193, + 48, + 183, + 155, + 139, + 46, + 35, + 136, + 193, + 8, + 155, + 97, + 250, + 81, + 234, + 55, + 129, + 145, + 9, + 181, + 239, + 100, + 218, + 18, + 80, + 245, + 214, + 181, + 215, + 76, + 195, + 146 + ], + "plaintext": [ + 155, + 164, + 205, + 94, + 96, + 2, + 119, + 244, + 199, + 134, + 206, + 130, + 126 + ], + "ciphertext": [ + 103, + 132, + 33, + 153, + 72, + 43, + 40, + 190, + 86, + 247, + 87, + 13, + 17 + ], + "tag": [ + 121, + 224, + 56, + 65, + 132, + 63, + 227, + 35, + 55, + 183, + 199, + 64, + 154, + 33, + 83, + 188 + ] + }, + { + "key": [ + 211, + 150, + 148, + 28, + 156, + 89, + 230, + 167, + 188, + 125, + 113, + 189, + 86, + 218, + 246, + 234, + 190, + 75, + 251, + 148, + 49, + 81, + 205, + 185, + 137, + 81, + 3, + 56, + 75, + 143, + 56, + 180 + ], + "nonce": [ + 244, + 8, + 248, + 194, + 31, + 56, + 37, + 215, + 168, + 118, + 67, + 237 + ], + "aad": [ + 148, + 123, + 217, + 169, + 4, + 224, + 63, + 221, + 44, + 145, + 208, + 56, + 210, + 109, + 72, + 172, + 110, + 50, + 175, + 202, + 217, + 8, + 234, + 205, + 66, + 162, + 95, + 98, + 64, + 150, + 70, + 86, + 213, + 164, + 147, + 36, + 45, + 63, + 138, + 25, + 17, + 154, + 76, + 217, + 149, + 125, + 156, + 66 + ], + "plaintext": [ + 220, + 138, + 214, + 165, + 8, + 18, + 178, + 95, + 27, + 10, + 247, + 11, + 238 + ], + "ciphertext": [ + 87, + 230, + 216, + 33, + 7, + 155, + 184, + 167, + 144, + 39, + 243, + 14, + 37 + ], + "tag": [ + 222, + 140, + 38, + 213, + 163, + 218, + 107, + 226, + 75, + 63, + 110, + 161, + 226, + 160, + 240, + 198 + ] + }, + { + "key": [ + 236, + 162, + 43, + 58, + 41, + 118, + 31, + 212, + 0, + 49, + 181, + 194, + 125, + 96, + 173, + 188, + 250, + 195, + 168, + 232, + 127, + 235, + 147, + 128, + 196, + 41, + 207, + 188, + 218, + 39, + 189, + 6 + ], + "nonce": [ + 78, + 111, + 227, + 209, + 249, + 137, + 210, + 239, + 184, + 41, + 49, + 104 + ], + "aad": [ + 41, + 190, + 177, + 240, + 187, + 107, + 86, + 130, + 104, + 185, + 199, + 56, + 57, + 145, + 160, + 159, + 208, + 61, + 167, + 225, + 99, + 148, + 136, + 22, + 158, + 79, + 88, + 236, + 100, + 81, + 202, + 214, + 212, + 198, + 32, + 134, + 238, + 229, + 157, + 246, + 78, + 82, + 163, + 101, + 39, + 115, + 61, + 140 + ], + "plaintext": [ + 68, + 214, + 166, + 175, + 125, + 144, + 190, + 23, + 170, + 192, + 32, + 73, + 164 + ], + "ciphertext": [ + 154, + 170, + 41, + 91, + 179, + 219, + 127, + 99, + 53, + 164, + 200, + 207, + 47 + ], + "tag": [ + 85, + 247, + 87, + 113, + 99, + 161, + 48, + 192, + 219, + 205, + 226, + 67, + 239, + 33, + 104, + 133 + ] + }, + { + "key": [ + 250, + 60, + 232, + 176, + 153, + 243, + 163, + 146, + 98, + 75, + 196, + 51, + 181, + 38, + 82, + 53, + 182, + 92, + 9, + 82, + 207, + 197, + 72, + 23, + 190, + 42, + 128, + 3, + 208, + 87, + 144, + 60 + ], + "nonce": [ + 49, + 104, + 180, + 229, + 14, + 254, + 150, + 179, + 211, + 174, + 214, + 0 + ], + "aad": [ + 212, + 81, + 250, + 100, + 215, + 59, + 125, + 126, + 238, + 143, + 129, + 67, + 196, + 11, + 171, + 142, + 63, + 122, + 88, + 238, + 1, + 138, + 205, + 162, + 50, + 36, + 151, + 79, + 100, + 172, + 126, + 30, + 56, + 159, + 80, + 88, + 236, + 8, + 102, + 75, + 245, + 100, + 146, + 185, + 50, + 209, + 95, + 66 + ], + "plaintext": [ + 132, + 237, + 60, + 205, + 66, + 141, + 55, + 131, + 236, + 234, + 24, + 11, + 59 + ], + "ciphertext": [ + 238, + 43, + 213, + 39, + 86, + 138, + 78, + 117, + 55, + 200, + 249, + 57, + 182 + ], + "tag": [ + 244, + 97, + 95, + 125, + 253, + 255, + 236, + 138, + 45, + 82, + 201, + 146, + 69, + 98, + 16, + 173 + ] + }, + { + "key": [ + 255, + 149, + 6, + 180, + 212, + 107, + 165, + 65, + 40, + 135, + 111, + 173, + 252, + 198, + 115, + 164, + 201, + 39, + 198, + 24, + 234, + 125, + 149, + 207, + 202, + 165, + 8, + 203, + 200, + 247, + 252, + 102 + ], + "nonce": [ + 55, + 66, + 173, + 34, + 8, + 160, + 72, + 67, + 69, + 238, + 225, + 190 + ], + "aad": [ + 241, + 54, + 10, + 39, + 253, + 194, + 68, + 190, + 135, + 57, + 216, + 90, + 246, + 73, + 28, + 118, + 42, + 105, + 58, + 175, + 230, + 104, + 196, + 73, + 81, + 95, + 222, + 238, + 219, + 106, + 144, + 174, + 238, + 56, + 145, + 187, + 200, + 182, + 154, + 220, + 106, + 100, + 38, + 203, + 18, + 252, + 222, + 188, + 50, + 201, + 245, + 140, + 82, + 89, + 209, + 40, + 185, + 30, + 250, + 40, + 98, + 10, + 58, + 154, + 1, + 104, + 176, + 255, + 94, + 118, + 149, + 28, + 180, + 22, + 71, + 186, + 74, + 161, + 248, + 127, + 172, + 13, + 151, + 172, + 88, + 14, + 66, + 207, + 252, + 126 + ], + "plaintext": [ + 127, + 208, + 214, + 202, + 220, + 146, + 202, + 210, + 123, + 178, + 215, + 216, + 200 + ], + "ciphertext": [ + 189, + 184, + 52, + 107, + 40, + 235, + 77, + 114, + 38, + 73, + 54, + 17, + 166 + ], + "tag": [ + 116, + 132, + 216, + 39, + 183, + 103, + 100, + 127, + 68, + 199, + 249, + 74, + 57, + 248, + 23, + 92 + ] + }, + { + "key": [ + 182, + 91, + 126, + 39, + 213, + 82, + 57, + 95, + 95, + 68, + 79, + 3, + 29, + 81, + 24, + 251, + 79, + 178, + 38, + 222, + 176, + 172, + 78, + 130, + 120, + 75, + 144, + 26, + 204, + 212, + 60, + 81 + ], + "nonce": [ + 36, + 147, + 2, + 104, + 85, + 221, + 28, + 29, + 163, + 175, + 123, + 126 + ], + "aad": [ + 183, + 142, + 49, + 177, + 121, + 60, + 43, + 117, + 132, + 148, + 233, + 200, + 174, + 125, + 60, + 238, + 110, + 54, + 151, + 212, + 15, + 251, + 160, + 77, + 60, + 108, + 190, + 37, + 225, + 46, + 238, + 163, + 101, + 213, + 162, + 231, + 180, + 108, + 66, + 69, + 119, + 27, + 123, + 46, + 178, + 6, + 42, + 100, + 14, + 96, + 144, + 217, + 248, + 28, + 175, + 99, + 32, + 120, + 101, + 187, + 79, + 44, + 76, + 246, + 175, + 129, + 137, + 133, + 96, + 227, + 174, + 170, + 82, + 29, + 205, + 44, + 51, + 110, + 14, + 197, + 127, + 175, + 254, + 245, + 134, + 131, + 167, + 39, + 16, + 185 + ], + "plaintext": [ + 138, + 219, + 54, + 210, + 194, + 53, + 142, + 80, + 91, + 93, + 33, + 74, + 208 + ], + "ciphertext": [ + 233, + 241, + 149, + 72, + 214, + 110, + 243, + 193, + 107, + 113, + 27, + 137, + 226 + ], + "tag": [ + 231, + 239, + 201, + 27, + 191, + 32, + 38, + 195, + 81, + 144, + 16, + 214, + 86, + 40, + 232, + 95 + ] + }, + { + "key": [ + 142, + 79, + 136, + 89, + 188, + 131, + 143, + 106, + 46, + 125, + 235, + 24, + 73, + 194, + 123, + 120, + 135, + 130, + 133, + 224, + 12, + 170, + 214, + 117, + 7, + 213, + 231, + 145, + 5, + 102, + 150, + 116 + ], + "nonce": [ + 231, + 29, + 14, + 187, + 105, + 26, + 76, + 49, + 253, + 217, + 135, + 156 + ], + "aad": [ + 71, + 202, + 108, + 239, + 60, + 167, + 121, + 151, + 239, + 27, + 4, + 227, + 114, + 20, + 105, + 190, + 68, + 10, + 214, + 129, + 42, + 163, + 103, + 74, + 233, + 44, + 160, + 22, + 179, + 145, + 210, + 2, + 226, + 153, + 50, + 237, + 250, + 131, + 2, + 158, + 204, + 174, + 144, + 189, + 141, + 190, + 75, + 67, + 78, + 115, + 4, + 178, + 143, + 226, + 73, + 179, + 128, + 178, + 195, + 196, + 147, + 36, + 253, + 91, + 62, + 70, + 158, + 62, + 19, + 90, + 188, + 28, + 159, + 215, + 120, + 40, + 180, + 9, + 199, + 72, + 46, + 106, + 99, + 70, + 28, + 5, + 151, + 177, + 78, + 92 + ], + "plaintext": [ + 189, + 23, + 19, + 216, + 210, + 118, + 223, + 67, + 103, + 191, + 60, + 187, + 129 + ], + "ciphertext": [ + 238, + 203, + 251, + 116, + 227, + 20, + 98, + 139, + 14, + 63, + 130, + 120, + 129 + ], + "tag": [ + 201, + 234, + 137, + 2, + 148, + 215, + 225, + 15, + 56, + 184, + 142, + 124, + 116, + 147, + 197, + 248 + ] + }, + { + "key": [ + 37, + 48, + 205, + 203, + 42, + 120, + 144, + 0, + 130, + 37, + 136, + 163, + 27, + 220, + 135, + 192, + 146, + 52, + 131, + 141, + 162, + 214, + 174, + 18, + 89, + 199, + 4, + 145, + 134, + 82, + 95, + 17 + ], + "nonce": [ + 12, + 80, + 159, + 170, + 37, + 125, + 187, + 14, + 116, + 58, + 83, + 172 + ], + "aad": [ + 146, + 169, + 44, + 184, + 193, + 152, + 78, + 222, + 128, + 96, + 40, + 204, + 69, + 172, + 149, + 87, + 65, + 103, + 238, + 131, + 240, + 58, + 112, + 124, + 196, + 176, + 251, + 138, + 215, + 9, + 7, + 224, + 1, + 110, + 56, + 182, + 80, + 244, + 167, + 91, + 200, + 58, + 98, + 94, + 60, + 103, + 7, + 1, + 212, + 59, + 251, + 3, + 38, + 209, + 196, + 254, + 124, + 104, + 65, + 7, + 51, + 192, + 200, + 116, + 201, + 32, + 56, + 157, + 22, + 75, + 246, + 122, + 144, + 50, + 226, + 232, + 55, + 245, + 233, + 227, + 36, + 185, + 121, + 50, + 209, + 249, + 23, + 186, + 125, + 202 + ], + "plaintext": [ + 168, + 237, + 197, + 36, + 147, + 12, + 228, + 194, + 8, + 151, + 198, + 111, + 117 + ], + "ciphertext": [ + 31, + 101, + 140, + 122, + 31, + 65, + 21, + 43, + 34, + 153, + 158, + 209, + 183 + ], + "tag": [ + 207, + 62, + 79, + 239, + 119, + 93, + 156, + 111, + 243, + 105, + 91, + 226, + 96, + 42, + 144, + 216 + ] + }, + { + "key": [ + 84, + 195, + 31, + 178, + 251, + 74, + 171, + 106, + 130, + 206, + 24, + 142, + 106, + 250, + 113, + 163, + 53, + 72, + 17, + 9, + 157, + 18, + 3, + 254, + 31, + 153, + 23, + 70, + 247, + 52, + 47, + 144 + ], + "nonce": [ + 240, + 254, + 151, + 75, + 219, + 225, + 105, + 77, + 195, + 176, + 108, + 198 + ], + "aad": [ + 40, + 121, + 224, + 94, + 15, + 141, + 212, + 64, + 36, + 37, + 234, + 187, + 13, + 193, + 132, + 220, + 208, + 125, + 70, + 213, + 77, + 119, + 93, + 124, + 43, + 118, + 176, + 247, + 107, + 62, + 237, + 95, + 124, + 169, + 60, + 106, + 231, + 27, + 245, + 9, + 194, + 112, + 73, + 2, + 105, + 234, + 134, + 158, + 214, + 96, + 63, + 223, + 113, + 19, + 170, + 98, + 86, + 72, + 171, + 142, + 216, + 130, + 16, + 248, + 179, + 14, + 201, + 201, + 75, + 202, + 87, + 87, + 202, + 61, + 119, + 73, + 31, + 100, + 16, + 145, + 1, + 22, + 86, + 54, + 176, + 104, + 227, + 9, + 92, + 180 + ], + "plaintext": [ + 251, + 183, + 179, + 115, + 15, + 12, + 215, + 177, + 5, + 42, + 82, + 152, + 238 + ], + "ciphertext": [ + 58, + 90, + 42, + 138, + 169, + 60, + 70, + 44, + 251, + 128, + 241, + 247, + 40 + ], + "tag": [ + 89, + 239, + 157, + 84, + 238, + 1, + 251, + 108, + 213, + 75, + 208, + 224, + 143, + 116, + 9, + 111 + ] + }, + { + "key": [ + 128, + 132, + 6, + 29, + 15, + 120, + 88, + 166, + 92, + 58, + 53, + 87, + 33, + 94, + 212, + 111, + 21, + 144, + 39, + 140, + 169, + 122, + 69, + 220, + 176, + 149, + 210, + 160, + 151, + 159, + 46, + 63 + ], + "nonce": [ + 105, + 115, + 137, + 139, + 26, + 143, + 114, + 133, + 100, + 21, + 103, + 91 + ], + "aad": [ + 139, + 84, + 62, + 41, + 69, + 70, + 132, + 140, + 51, + 8, + 204, + 234, + 48, + 47, + 2, + 56, + 183, + 223, + 252, + 23, + 6, + 208, + 54, + 87, + 193, + 144, + 234, + 116, + 92, + 199, + 91, + 205, + 90, + 67, + 121, + 147, + 231, + 135, + 130, + 142, + 167, + 254, + 66, + 254, + 161, + 213, + 198, + 247, + 34, + 154, + 114, + 234, + 101, + 240, + 208, + 193, + 144, + 152, + 154, + 89, + 10, + 180, + 156, + 84, + 114, + 102, + 51, + 40, + 44, + 104, + 158, + 239, + 140, + 248, + 82, + 175, + 38, + 59, + 94, + 223, + 99, + 228, + 73, + 253, + 84, + 64, + 115, + 0, + 3, + 202 + ], + "plaintext": [ + 32, + 13, + 4, + 69, + 203, + 9, + 235, + 82, + 245, + 77, + 47, + 116, + 198 + ], + "ciphertext": [ + 236, + 36, + 44, + 53, + 129, + 147, + 202, + 97, + 135, + 200, + 154, + 167, + 165 + ], + "tag": [ + 150, + 116, + 40, + 172, + 105, + 86, + 82, + 91, + 168, + 29, + 89, + 1, + 237, + 37, + 148, + 7 + ] + }, + { + "key": [ + 42, + 173, + 125, + 184, + 45, + 244, + 160, + 210, + 236, + 133, + 33, + 141, + 169, + 214, + 26, + 222, + 152, + 246, + 95, + 238, + 184, + 83, + 45, + 142, + 183, + 40, + 239, + 138, + 172, + 34, + 13, + 166 + ], + "nonce": [ + 2, + 154, + 194, + 233, + 245, + 220, + 61, + 118, + 176, + 209, + 249, + 223 + ], + "aad": [ + 214, + 244, + 182, + 35, + 45, + 23, + 177, + 188, + 48, + 121, + 18, + 161, + 95, + 57, + 204, + 209, + 133, + 164, + 101, + 238, + 134, + 2, + 121, + 233, + 142, + 185, + 85, + 20, + 152, + 215, + 176, + 120, + 39, + 30, + 186, + 189, + 218, + 114, + 17, + 230, + 180, + 171, + 24, + 112, + 67, + 23, + 27, + 197, + 228, + 191, + 159, + 252, + 248, + 154, + 119, + 132, + 48, + 231, + 53, + 223, + 41, + 65, + 10, + 69, + 202, + 53, + 75, + 0, + 3, + 67, + 60, + 107, + 200, + 89, + 62, + 232, + 46, + 124, + 9, + 106, + 50, + 234, + 199, + 109, + 17, + 218, + 167, + 214, + 65, + 80 + ], + "plaintext": [ + 186, + 54, + 57, + 18, + 246, + 32, + 124, + 84, + 174, + 205, + 38, + 182, + 39 + ], + "ciphertext": [ + 191, + 202, + 211, + 38, + 17, + 218, + 39, + 90, + 15, + 8, + 33, + 81, + 124 + ], + "tag": [ + 158, + 163, + 123, + 220, + 170, + 250, + 214, + 156, + 175, + 6, + 214, + 127, + 177, + 141, + 208, + 1 + ] + }, + { + "key": [ + 247, + 11, + 185, + 80, + 171, + 86, + 241, + 47, + 30, + 252, + 35, + 118, + 211, + 42, + 89, + 209, + 110, + 243, + 239, + 89, + 105, + 224, + 16, + 106, + 180, + 12, + 195, + 20, + 201, + 176, + 199, + 232 + ], + "nonce": [ + 59, + 59, + 41, + 186, + 66, + 44, + 43, + 172, + 175, + 238, + 184, + 179 + ], + "aad": [ + 70, + 74, + 192, + 200, + 75, + 159, + 241, + 122, + 14, + 124, + 57, + 166, + 95, + 137, + 104, + 42, + 137, + 184, + 120, + 117, + 83, + 166, + 39, + 95, + 13, + 85, + 239, + 250, + 171, + 239, + 33, + 20, + 7, + 44, + 115, + 159, + 152, + 49, + 165, + 213, + 165, + 19, + 58, + 228, + 222, + 20, + 235, + 81, + 52, + 107, + 49, + 139, + 37, + 90, + 27, + 255, + 87, + 229, + 12, + 67, + 62, + 30, + 105, + 160, + 15, + 225, + 168, + 182, + 246, + 182, + 33, + 213, + 21, + 214, + 112, + 216, + 158, + 20, + 143, + 107, + 101, + 214, + 235, + 76, + 84, + 135, + 140, + 184, + 25, + 206 + ], + "plaintext": [ + 2, + 153, + 41, + 39, + 112, + 67, + 220, + 3, + 121, + 241, + 82, + 164, + 132 + ], + "ciphertext": [ + 192, + 185, + 125, + 109, + 26, + 149, + 215, + 8, + 214, + 220, + 125, + 43, + 149 + ], + "tag": [ + 50, + 46, + 180, + 57, + 91, + 244, + 212, + 221, + 7, + 11, + 143, + 159, + 97, + 149, + 248, + 238 + ] + }, + { + "key": [ + 244, + 149, + 15, + 1, + 203, + 17, + 253, + 217, + 175, + 178, + 151, + 247, + 170, + 133, + 47, + 172, + 250, + 195, + 84, + 255, + 150, + 85, + 123, + 239, + 165, + 246, + 87, + 103, + 141, + 230, + 206, + 251 + ], + "nonce": [ + 171, + 167, + 216, + 100, + 242, + 156, + 188, + 68, + 156, + 217, + 62, + 51 + ], + "aad": [ + 133, + 47, + 98, + 76, + 234, + 122, + 140, + 32, + 225, + 137, + 224, + 199, + 159, + 87, + 140, + 13, + 119, + 12, + 75, + 247, + 196, + 230, + 145, + 100, + 158, + 186, + 153, + 47, + 109, + 232, + 157, + 123, + 242, + 7, + 138, + 255, + 148, + 128, + 58, + 61, + 198, + 38, + 40, + 224, + 42, + 128, + 160, + 25, + 87, + 114, + 46, + 42, + 147, + 31, + 197, + 98, + 131, + 216, + 74, + 182, + 140, + 225, + 26, + 232, + 103, + 131, + 92, + 45, + 151, + 0, + 223, + 19, + 0, + 72, + 234, + 142, + 170, + 202, + 65, + 241, + 169, + 5, + 155, + 226, + 172, + 174, + 166, + 224, + 247, + 242 + ], + "plaintext": [ + 230, + 218, + 245, + 158, + 245, + 74, + 199, + 64, + 89, + 132, + 252, + 76, + 78 + ], + "ciphertext": [ + 208, + 29, + 54, + 255, + 128, + 9, + 180, + 8, + 34, + 121, + 171, + 185, + 6 + ], + "tag": [ + 217, + 163, + 108, + 128, + 8, + 73, + 59, + 217, + 92, + 9, + 4, + 146, + 153, + 203, + 208, + 117 + ] + }, + { + "key": [ + 113, + 66, + 97, + 239, + 79, + 2, + 251, + 78, + 251, + 14, + 107, + 90, + 237, + 150, + 215, + 179, + 206, + 172, + 101, + 81, + 165, + 124, + 246, + 121, + 218, + 23, + 156, + 1, + 170, + 197, + 238, + 14 + ], + "nonce": [ + 59, + 125, + 21, + 199, + 253, + 135, + 116, + 97, + 167, + 137, + 37, + 90 + ], + "aad": [ + 118, + 33, + 229, + 129, + 82, + 51, + 110, + 228, + 21, + 240, + 55, + 242, + 225, + 21, + 129, + 254, + 77, + 165, + 69, + 193, + 141, + 110, + 128, + 23, + 125, + 90, + 181, + 221, + 168, + 154, + 37, + 232, + 5, + 125, + 111, + 204, + 236, + 55, + 87, + 117, + 154, + 110, + 134, + 230, + 49, + 8, + 12, + 11, + 23, + 186, + 168, + 190, + 11, + 143, + 229, + 121, + 211, + 191, + 169, + 121, + 55, + 238, + 36, + 43, + 111, + 170, + 207, + 192, + 148, + 37, + 133, + 61, + 244, + 220, + 38, + 188, + 38, + 62, + 209, + 8, + 58, + 115, + 255, + 201, + 120, + 201, + 38, + 95, + 128, + 105 + ], + "plaintext": [ + 129, + 93, + 232, + 176, + 56, + 47, + 230, + 12, + 176, + 211, + 120, + 46, + 233 + ], + "ciphertext": [ + 41, + 197, + 102, + 234, + 71, + 117, + 42, + 49, + 163, + 128, + 253, + 14, + 124 + ], + "tag": [ + 178, + 121, + 52, + 10, + 56, + 77, + 187, + 174, + 114, + 28, + 84, + 233, + 24, + 59, + 57, + 102 + ] + }, + { + "key": [ + 83, + 69, + 155, + 165, + 162, + 228, + 157, + 26, + 124, + 47, + 182, + 173, + 158, + 105, + 97, + 180, + 219, + 229, + 21, + 140, + 185, + 38, + 110, + 255, + 66, + 93, + 109, + 204, + 202, + 175, + 128, + 115 + ], + "nonce": [ + 60, + 151, + 220, + 99, + 90, + 117, + 251, + 226, + 195, + 60, + 154, + 65 + ], + "aad": [ + 127, + 227, + 8, + 175, + 229, + 138, + 146, + 118, + 128, + 190, + 227, + 54, + 131, + 1, + 244, + 220, + 124, + 71, + 129, + 31, + 192, + 159, + 27, + 153, + 34, + 160, + 146, + 164, + 151, + 185, + 198, + 182, + 124, + 133, + 127, + 220, + 195, + 45, + 161, + 1, + 26, + 203, + 17, + 11, + 60, + 20, + 117, + 190, + 243, + 3, + 241, + 166, + 9, + 71, + 148, + 133, + 204, + 64, + 14, + 232, + 243, + 131, + 129, + 196, + 93, + 7, + 135, + 8, + 173, + 73, + 242, + 38, + 249, + 93, + 217, + 200, + 20, + 120, + 209, + 238, + 43, + 83, + 195, + 185, + 6, + 217, + 111, + 141, + 221, + 118 + ], + "plaintext": [ + 3, + 251, + 254, + 88, + 66, + 237, + 120, + 25, + 144, + 202, + 139, + 231, + 40 + ], + "ciphertext": [ + 88, + 101, + 229, + 161, + 236, + 113, + 23, + 50, + 164, + 238, + 135, + 27, + 255 + ], + "tag": [ + 133, + 106, + 101, + 62, + 194, + 20, + 23, + 128, + 150, + 190, + 212, + 35, + 227, + 10, + 54, + 233 + ] + }, + { + "key": [ + 240, + 80, + 21, + 131, + 194, + 38, + 210, + 81, + 158, + 210, + 63, + 204, + 111, + 44, + 255, + 210, + 240, + 19, + 235, + 145, + 170, + 7, + 179, + 165, + 162, + 7, + 61, + 110, + 43, + 209, + 12, + 239 + ], + "nonce": [ + 41, + 169, + 34, + 173, + 155, + 222, + 221, + 194, + 226, + 152, + 185, + 159 + ], + "aad": [ + 216, + 79, + 84, + 186, + 192, + 158, + 169, + 42, + 254, + 10, + 115, + 53, + 203, + 11, + 181, + 246, + 132, + 37, + 73, + 15, + 210, + 251, + 108, + 59, + 153, + 33, + 143, + 73, + 133, + 110, + 212, + 39, + 236, + 144, + 46, + 81, + 11, + 137, + 157, + 84, + 149, + 31, + 232, + 76, + 219, + 253, + 17, + 38, + 8, + 209, + 233, + 153, + 246, + 78, + 204, + 156, + 212, + 190, + 58, + 1, + 20, + 193, + 195, + 72, + 117, + 219, + 243, + 90, + 27, + 11, + 228, + 33, + 101, + 159, + 153, + 214, + 155, + 50, + 233, + 104, + 206, + 191, + 202, + 111, + 149, + 131, + 126, + 62, + 222, + 180 + ], + "plaintext": [ + 3, + 94, + 182, + 146, + 35, + 69, + 192, + 42, + 129, + 67, + 93, + 158, + 119 + ], + "ciphertext": [ + 9, + 89, + 113, + 249, + 154, + 244, + 103, + 128, + 90, + 98, + 191, + 184, + 130 + ], + "tag": [ + 213, + 255, + 43, + 123, + 234, + 194, + 96, + 229, + 23, + 234, + 62, + 202, + 19, + 255, + 30, + 119 + ] + }, + { + "key": [ + 120, + 230, + 120, + 155, + 89, + 108, + 113, + 203, + 59, + 236, + 200, + 51, + 207, + 130, + 61, + 46, + 187, + 24, + 202, + 46, + 38, + 194, + 126, + 38, + 165, + 94, + 249, + 93, + 247, + 53, + 57, + 113 + ], + "nonce": [ + 101, + 218, + 156, + 122, + 159, + 23, + 177, + 18, + 70, + 188, + 248, + 219 + ], + "aad": [ + 212, + 154, + 238, + 127, + 253, + 49, + 231, + 200, + 216, + 49, + 217, + 122, + 232, + 148, + 160, + 4, + 115, + 173, + 188, + 80, + 113, + 246, + 9, + 157, + 86, + 124, + 170, + 239, + 133, + 194, + 149, + 213, + 20, + 58, + 19, + 22, + 255, + 130, + 117, + 60, + 195, + 93, + 62, + 252, + 96, + 247, + 229, + 16, + 29, + 221, + 129, + 19, + 54, + 180, + 4, + 213, + 152, + 246, + 196, + 57, + 204, + 230, + 180, + 127, + 203, + 235, + 177, + 93, + 28, + 52, + 46, + 65, + 81, + 179, + 85, + 2, + 90, + 3, + 180, + 57, + 114, + 96, + 180, + 167, + 230, + 68, + 79, + 165, + 123, + 91 + ], + "plaintext": [ + 0, + 62, + 130, + 161, + 71, + 223, + 60, + 149, + 52, + 0, + 248, + 122, + 181 + ], + "ciphertext": [ + 171, + 204, + 236, + 237, + 64, + 32, + 159, + 195, + 10, + 85, + 144, + 254, + 232 + ], + "tag": [ + 10, + 32, + 57, + 115, + 184, + 19, + 117, + 148, + 158, + 189, + 147, + 37, + 151, + 239, + 212, + 149 + ] + }, + { + "key": [ + 129, + 107, + 62, + 108, + 163, + 29, + 89, + 104, + 140, + 32, + 188, + 209, + 250, + 66, + 133, + 25, + 119, + 53, + 216, + 115, + 66, + 137, + 202, + 25, + 164, + 115, + 14, + 86, + 241, + 99, + 28, + 207 + ], + "nonce": [ + 76, + 25, + 26, + 201, + 148, + 248, + 105, + 133, + 193, + 128, + 204, + 212 + ], + "aad": [ + 179, + 220, + 214, + 67, + 198, + 140, + 204, + 225, + 134, + 87, + 12, + 99, + 40, + 140, + 135, + 34, + 184, + 161, + 61, + 250, + 249, + 231, + 31, + 68, + 241, + 238, + 180, + 84, + 164, + 77, + 221, + 245, + 249, + 85, + 84, + 12, + 212, + 108, + 159, + 59, + 111, + 130, + 5, + 136, + 247, + 25, + 54, + 215, + 168, + 197, + 76, + 123, + 123, + 196, + 63, + 88, + 187, + 72, + 230, + 65, + 97, + 73, + 254, + 174, + 122, + 63, + 141, + 129, + 152, + 169, + 112, + 129, + 22, + 39, + 72, + 146, + 102, + 168, + 113, + 232, + 203, + 135, + 135, + 140, + 219, + 58, + 72, + 190, + 101, + 245 + ], + "plaintext": [ + 178, + 6, + 13, + 216, + 107, + 195, + 7, + 19, + 59, + 125, + 54, + 88, + 48 + ], + "ciphertext": [ + 83, + 230, + 88, + 128, + 173, + 0, + 18, + 167, + 95, + 17, + 136, + 153, + 111 + ], + "tag": [ + 156, + 168, + 167, + 26, + 69, + 235, + 68, + 2, + 166, + 176, + 49, + 6, + 186, + 227, + 48, + 209 + ] + }, + { + "key": [ + 160, + 123, + 165, + 116, + 120, + 6, + 27, + 215, + 171, + 221, + 215, + 98, + 151, + 28, + 242, + 228, + 113, + 65, + 137, + 31, + 118, + 195, + 209, + 193, + 80, + 181, + 62, + 238, + 87, + 4, + 85, + 125 + ], + "nonce": [ + 90, + 223, + 184, + 91, + 45, + 158, + 35, + 156, + 81, + 70, + 80, + 29 + ], + "aad": [ + 147, + 123, + 62, + 215, + 62, + 103, + 202, + 11, + 2, + 249, + 235, + 115, + 106, + 102, + 131, + 98, + 212, + 208, + 68, + 124, + 21, + 246, + 8, + 48, + 153, + 167, + 249, + 12, + 124, + 73, + 49, + 141, + 215, + 47, + 107, + 170, + 116, + 218, + 34, + 255, + 83, + 181, + 108, + 36, + 251, + 154, + 27, + 29, + 108, + 78, + 41, + 244, + 172, + 77, + 145, + 114, + 32, + 235, + 227, + 200, + 215, + 96, + 153, + 157, + 167, + 190, + 158, + 30, + 143, + 106, + 23, + 17, + 51, + 100, + 12, + 145, + 150, + 249, + 238, + 60, + 219, + 118, + 165, + 163, + 66, + 169, + 90, + 5, + 200, + 196 + ], + "plaintext": [ + 103, + 200, + 130, + 76, + 24, + 55, + 207, + 222, + 198, + 237, + 205, + 113, + 156 + ], + "ciphertext": [ + 30, + 184, + 92, + 102, + 130, + 133, + 14, + 132, + 158, + 179, + 121, + 39, + 229 + ], + "tag": [ + 128, + 121, + 247, + 5, + 207, + 85, + 26, + 84, + 132, + 19, + 44, + 208, + 240, + 197, + 41, + 124 + ] + }, + { + "key": [ + 38, + 142, + 209, + 181, + 215, + 201, + 199, + 48, + 79, + 156, + 174, + 95, + 196, + 55, + 180, + 205, + 58, + 235, + 226, + 236, + 101, + 240, + 216, + 92, + 57, + 24, + 211, + 211, + 181, + 187, + 168, + 155 + ], + "nonce": [ + 158, + 217, + 216, + 24, + 5, + 100, + 224, + 233, + 69, + 245, + 229, + 212 + ], + "aad": [], + "plaintext": [ + 254, + 41, + 164, + 13, + 142, + 191, + 87, + 38, + 43, + 219, + 135, + 25, + 29, + 1, + 132, + 63, + 76, + 164, + 178, + 222, + 151, + 216, + 130, + 115, + 21, + 74, + 11, + 125, + 158, + 47, + 219, + 128 + ], + "ciphertext": [ + 121, + 26, + 74, + 2, + 111, + 22, + 243, + 165, + 234, + 6, + 39, + 75, + 240, + 43, + 170, + 180, + 105, + 134, + 10, + 189, + 229, + 230, + 69, + 243, + 221, + 71, + 58, + 90, + 205, + 222, + 236, + 252 + ], + "tag": [ + 5, + 178, + 183, + 77, + 176, + 102, + 37, + 80, + 67, + 94, + 241, + 144, + 14, + 19, + 107, + 21 + ] + }, + { + "key": [ + 199, + 114, + 168, + 213, + 233, + 243, + 56, + 79, + 22, + 190, + 44, + 52, + 191, + 154, + 253, + 158, + 191, + 134, + 182, + 158, + 111, + 97, + 12, + 209, + 149, + 169, + 219, + 22, + 158, + 155, + 225, + 126 + ], + "nonce": [ + 155, + 142, + 7, + 159, + 153, + 113, + 215, + 53, + 46, + 104, + 16, + 163 + ], + "aad": [], + "plaintext": [ + 127, + 19, + 252, + 175, + 13, + 183, + 157, + 121, + 40, + 35, + 169, + 39, + 27, + 18, + 19, + 169, + 141, + 17, + 110, + 255, + 126, + 142, + 60, + 134, + 221, + 235, + 106, + 10, + 3, + 241, + 58, + 250 + ], + "ciphertext": [ + 210, + 158, + 43, + 243, + 81, + 134, + 104, + 161, + 79, + 23, + 163, + 228, + 231, + 110, + 27, + 67, + 104, + 87, + 52, + 184, + 1, + 17, + 141, + 51, + 162, + 50, + 56, + 243, + 77, + 24, + 170, + 64 + ], + "tag": [ + 142, + 2, + 176, + 183, + 209, + 114, + 207, + 94, + 37, + 120, + 245, + 179, + 15, + 172, + 46, + 122 + ] + }, + { + "key": [ + 213, + 146, + 75, + 49, + 103, + 110, + 35, + 84, + 254, + 125, + 175, + 255, + 175, + 82, + 151, + 73, + 89, + 142, + 161, + 191, + 94, + 76, + 68, + 245, + 182, + 2, + 64, + 224, + 157, + 128, + 54, + 170 + ], + "nonce": [ + 93, + 132, + 119, + 132, + 240, + 188, + 215, + 156, + 184, + 79, + 207, + 29 + ], + "aad": [], + "plaintext": [ + 111, + 216, + 12, + 143, + 13, + 77, + 224, + 129, + 169, + 60, + 22, + 184, + 77, + 236, + 105, + 122, + 30, + 79, + 157, + 128, + 166, + 175, + 73, + 124, + 86, + 21, + 114, + 100, + 94, + 172, + 13, + 99 + ], + "ciphertext": [ + 40, + 44, + 201, + 210, + 48, + 138, + 68, + 48, + 25, + 207, + 220, + 77, + 121, + 133, + 74, + 204, + 199, + 115, + 30, + 227, + 105, + 2, + 186, + 254, + 63, + 250, + 202, + 100, + 132, + 50, + 123, + 130 + ], + "tag": [ + 77, + 197, + 224, + 242, + 171, + 145, + 189, + 253, + 49, + 242, + 189, + 207, + 6, + 175, + 150, + 103 + ] + }, + { + "key": [ + 179, + 40, + 198, + 215, + 148, + 98, + 33, + 160, + 140, + 79, + 5, + 9, + 181, + 41, + 146, + 161, + 57, + 137, + 12, + 221, + 142, + 174, + 25, + 86, + 133, + 31, + 17, + 12, + 73, + 96, + 44, + 181 + ], + "nonce": [ + 26, + 67, + 60, + 51, + 202, + 18, + 206, + 38, + 207, + 61, + 255, + 255 + ], + "aad": [], + "plaintext": [ + 33, + 123, + 220, + 49, + 74, + 77, + 51, + 92, + 114, + 181, + 38, + 123, + 66, + 79, + 200, + 227, + 31, + 75, + 177, + 24, + 230, + 207, + 174, + 172, + 245, + 84, + 143, + 75, + 168, + 245, + 25, + 128 + ], + "ciphertext": [ + 163, + 34, + 148, + 78, + 7, + 191, + 132, + 171, + 66, + 79, + 250, + 117, + 253, + 3, + 9, + 232, + 105, + 28, + 144, + 54, + 176, + 143, + 52, + 75, + 167, + 108, + 224, + 119, + 79, + 67, + 179, + 81 + ], + "tag": [ + 20, + 221, + 107, + 28, + 43, + 34, + 69, + 51, + 204, + 201, + 254, + 232, + 210, + 136, + 19, + 88 + ] + }, + { + "key": [ + 194, + 8, + 9, + 101, + 210, + 29, + 34, + 156, + 13, + 13, + 108, + 86, + 203, + 206, + 131, + 136, + 1, + 32, + 194, + 26, + 72, + 23, + 42, + 100, + 86, + 11, + 144, + 220, + 76, + 225, + 255, + 190 + ], + "nonce": [ + 146, + 141, + 108, + 1, + 149, + 245, + 240, + 151, + 79, + 56, + 115, + 11 + ], + "aad": [], + "plaintext": [ + 134, + 67, + 151, + 39, + 30, + 27, + 36, + 42, + 161, + 223, + 243, + 142, + 120, + 170, + 137, + 53, + 62, + 21, + 84, + 186, + 144, + 115, + 24, + 160, + 170, + 173, + 68, + 242, + 111, + 205, + 86, + 125 + ], + "ciphertext": [ + 125, + 228, + 249, + 65, + 244, + 75, + 208, + 242, + 104, + 178, + 164, + 123, + 156, + 73, + 39, + 204, + 16, + 83, + 123, + 190, + 215, + 57, + 213, + 42, + 176, + 153, + 253, + 228, + 3, + 48, + 65, + 209 + ], + "tag": [ + 181, + 26, + 89, + 147, + 24, + 23, + 37, + 118, + 25, + 231, + 190, + 16, + 145, + 18, + 140, + 73 + ] + }, + { + "key": [ + 221, + 107, + 126, + 37, + 132, + 237, + 241, + 241, + 230, + 194, + 192, + 221, + 31, + 114, + 22, + 26, + 146, + 210, + 203, + 169, + 152, + 86, + 85, + 79, + 130, + 13, + 225, + 37, + 109, + 72, + 192, + 153 + ], + "nonce": [ + 254, + 157, + 85, + 60, + 117, + 6, + 126, + 141, + 186, + 225, + 171, + 103 + ], + "aad": [], + "plaintext": [ + 249, + 248, + 111, + 119, + 98, + 133, + 159, + 17, + 214, + 231, + 239, + 86, + 23, + 134, + 87, + 221, + 205, + 237, + 83, + 40, + 67, + 68, + 111, + 134, + 162, + 62, + 172, + 53, + 170, + 45, + 211, + 192 + ], + "ciphertext": [ + 247, + 170, + 161, + 113, + 28, + 128, + 146, + 120, + 59, + 5, + 180, + 229, + 230, + 201, + 198, + 148, + 78, + 153, + 27, + 213, + 156, + 148, + 185, + 208, + 53, + 109, + 240, + 10, + 102, + 226, + 219, + 91 + ], + "tag": [ + 198, + 30, + 221, + 23, + 108, + 131, + 34, + 160, + 29, + 140, + 95, + 61, + 240, + 146, + 82, + 233 + ] + }, + { + "key": [ + 55, + 243, + 145, + 55, + 65, + 107, + 175, + 222, + 111, + 117, + 2, + 42, + 122, + 82, + 124, + 197, + 147, + 182, + 0, + 10, + 131, + 255, + 81, + 236, + 4, + 135, + 26, + 15, + 245, + 54, + 14, + 78 + ], + "nonce": [ + 162, + 145, + 72, + 76, + 61, + 232, + 190, + 198, + 180, + 127, + 82, + 95 + ], + "aad": [], + "plaintext": [ + 250, + 253, + 148, + 206, + 222, + 139, + 90, + 7, + 48, + 57, + 75, + 236, + 104, + 168, + 231, + 125, + 186, + 40, + 141, + 108, + 202, + 168, + 225, + 86, + 58, + 129, + 214, + 231, + 204, + 199, + 252, + 151 + ], + "ciphertext": [ + 68, + 220, + 134, + 128, + 6, + 178, + 29, + 73, + 40, + 64, + 22, + 86, + 95, + 251, + 57, + 121, + 204, + 66, + 113, + 217, + 103, + 98, + 139, + 247, + 205, + 175, + 134, + 219, + 136, + 142, + 146, + 229 + ], + "tag": [ + 1, + 162, + 181, + 120, + 170, + 47, + 65, + 236, + 99, + 121, + 164, + 74, + 49, + 204, + 1, + 156 + ] + }, + { + "key": [ + 162, + 239, + 97, + 144, + 84, + 22, + 64, + 115, + 192, + 106, + 25, + 27, + 100, + 49, + 196, + 192, + 188, + 38, + 144, + 80, + 141, + 203, + 110, + 136, + 168, + 57, + 106, + 19, + 145, + 41, + 20, + 131 + ], + "nonce": [ + 22, + 198, + 210, + 2, + 36, + 181, + 86, + 168, + 173, + 126, + 96, + 7 + ], + "aad": [], + "plaintext": [ + 148, + 154, + 159, + 133, + 150, + 111, + 74, + 49, + 124, + 245, + 146, + 231, + 12, + 95, + 181, + 156, + 76, + 172, + 189, + 8, + 20, + 12, + 129, + 105, + 186, + 16, + 178, + 232, + 121, + 26, + 229, + 123 + ], + "ciphertext": [ + 181, + 5, + 74, + 57, + 46, + 95, + 6, + 114, + 231, + 146, + 42, + 194, + 67, + 185, + 59, + 67, + 46, + 140, + 88, + 39, + 79, + 244, + 166, + 211, + 170, + 140, + 182, + 84, + 228, + 148, + 226, + 242 + ], + "tag": [ + 207, + 43, + 189, + 183, + 64, + 54, + 156, + 20, + 14, + 147, + 226, + 81, + 230, + 245, + 200, + 117 + ] + }, + { + "key": [ + 118, + 243, + 134, + 188, + 139, + 147, + 131, + 25, + 3, + 144, + 27, + 94, + 218, + 31, + 119, + 149, + 175, + 138, + 220, + 236, + 255, + 168, + 174, + 240, + 4, + 183, + 84, + 163, + 83, + 198, + 45, + 142 + ], + "nonce": [ + 150, + 97, + 139, + 53, + 124, + 65, + 244, + 26, + 44, + 72, + 52, + 59 + ], + "aad": [], + "plaintext": [ + 54, + 16, + 142, + 218, + 213, + 222, + 59, + 251, + 2, + 88, + 223, + 119, + 9, + 251, + 187, + 26, + 21, + 124, + 54, + 50, + 31, + 141, + 231, + 46, + 184, + 50, + 14, + 154, + 161, + 121, + 73, + 51 + ], + "ciphertext": [ + 178, + 9, + 58, + 79, + 200, + 255, + 13, + 174, + 252, + 28, + 120, + 107, + 107, + 4, + 50, + 74, + 128, + 215, + 121, + 65, + 168, + 142, + 10, + 122, + 110, + 240, + 166, + 43, + 235, + 142, + 210, + 131 + ], + "tag": [ + 229, + 94, + 160, + 69, + 106, + 249, + 205, + 255, + 44, + 173, + 78, + 235, + 191, + 0, + 218, + 27 + ] + }, + { + "key": [ + 111, + 178, + 209, + 48, + 187, + 173, + 25, + 36, + 202, + 179, + 125, + 7, + 21, + 83, + 177, + 33, + 105, + 233, + 120, + 168, + 5, + 191, + 116, + 203, + 76, + 35, + 213, + 204, + 211, + 147, + 215, + 187 + ], + "nonce": [ + 118, + 130, + 103, + 65, + 34, + 90, + 57, + 31, + 220, + 228, + 211, + 182 + ], + "aad": [], + "plaintext": [ + 196, + 155, + 128, + 8, + 14, + 46, + 254, + 181, + 114, + 75, + 158, + 91, + 83, + 186, + 12, + 48, + 46, + 151, + 189, + 22, + 241, + 166, + 187, + 236, + 1, + 225, + 202, + 108, + 53, + 164, + 42, + 60 + ], + "ciphertext": [ + 98, + 251, + 229, + 70, + 106, + 127, + 248, + 63, + 247, + 25, + 244, + 146, + 126, + 0, + 233, + 49, + 158, + 27, + 183, + 232, + 53, + 197, + 214, + 180, + 233, + 212, + 188, + 90, + 141, + 110, + 43, + 235 + ], + "tag": [ + 223, + 114, + 218, + 122, + 102, + 203, + 82, + 87, + 131, + 111, + 60, + 25, + 236, + 173, + 205, + 85 + ] + }, + { + "key": [ + 64, + 46, + 129, + 19, + 151, + 2, + 87, + 217, + 67, + 120, + 7, + 98, + 0, + 152, + 55, + 2, + 67, + 83, + 106, + 16, + 92, + 202, + 79, + 188, + 129, + 161, + 255, + 45, + 72, + 135, + 79, + 72 + ], + "nonce": [ + 201, + 36, + 193, + 156, + 77, + 20, + 144, + 90, + 43, + 223, + 99, + 191 + ], + "aad": [], + "plaintext": [ + 145, + 123, + 149, + 133, + 246, + 94, + 89, + 191, + 77, + 36, + 43, + 176, + 128, + 41, + 102, + 4, + 93, + 210, + 159, + 188, + 102, + 145, + 18, + 119, + 186, + 236, + 223, + 204, + 129, + 140, + 60, + 53 + ], + "ciphertext": [ + 91, + 101, + 148, + 237, + 205, + 219, + 179, + 56, + 244, + 232, + 19, + 104, + 127, + 79, + 35, + 167, + 90, + 100, + 194, + 30, + 60, + 245, + 210, + 231, + 201, + 175, + 15, + 126, + 62, + 227, + 230, + 22 + ], + "tag": [ + 241, + 204, + 205, + 147, + 164, + 65, + 18, + 71, + 200, + 182, + 131, + 10, + 221, + 215, + 44, + 111 + ] + }, + { + "key": [ + 42, + 172, + 73, + 156, + 176, + 235, + 114, + 180, + 89, + 138, + 207, + 244, + 51, + 13, + 246, + 205, + 118, + 73, + 120, + 153, + 125, + 90, + 206, + 81, + 218, + 136, + 224, + 193, + 134, + 113, + 189, + 233 + ], + "nonce": [ + 253, + 22, + 205, + 195, + 157, + 127, + 11, + 146, + 225, + 249, + 92, + 151 + ], + "aad": [], + "plaintext": [ + 231, + 183, + 91, + 250, + 53, + 201, + 160, + 4, + 208, + 182, + 130, + 101, + 98, + 58, + 155, + 6, + 182, + 212, + 73, + 62, + 160, + 173, + 79, + 108, + 119, + 123, + 165, + 173, + 216, + 199, + 187, + 187 + ], + "ciphertext": [ + 195, + 208, + 160, + 247, + 206, + 151, + 32, + 201, + 90, + 172, + 134, + 21, + 26, + 173, + 99, + 72, + 132, + 221, + 250, + 98, + 223, + 88, + 241, + 131, + 148, + 83, + 127, + 101, + 4, + 217, + 168, + 170 + ], + "tag": [ + 118, + 116, + 154, + 30, + 199, + 2, + 54, + 178, + 103, + 252, + 52, + 13, + 95, + 187, + 109, + 163 + ] + }, + { + "key": [ + 162, + 165, + 2, + 214, + 187, + 25, + 8, + 147, + 81, + 226, + 40, + 213, + 203, + 255, + 32, + 62, + 84, + 252, + 49, + 242, + 119, + 34, + 83, + 223, + 8, + 85, + 120, + 117, + 217, + 100, + 194, + 49 + ], + "nonce": [ + 14, + 187, + 90, + 244, + 164, + 98, + 161, + 230, + 222, + 215, + 22, + 74 + ], + "aad": [], + "plaintext": [ + 187, + 236, + 200, + 148, + 80, + 192, + 123, + 141, + 230, + 49, + 21, + 94, + 93, + 124, + 199, + 169, + 210, + 99, + 118, + 187, + 87, + 215, + 69, + 141, + 73, + 180, + 195, + 110, + 20, + 4, + 144, + 243 + ], + "ciphertext": [ + 253, + 9, + 201, + 80, + 137, + 4, + 65, + 252, + 170, + 168, + 128, + 154, + 137, + 152, + 7, + 154, + 187, + 136, + 116, + 28, + 102, + 114, + 171, + 174, + 18, + 56, + 63, + 253, + 114, + 79, + 130, + 153 + ], + "tag": [ + 34, + 250, + 194, + 70, + 5, + 139, + 241, + 66, + 197, + 242, + 104, + 18, + 166, + 53, + 180, + 128 + ] + }, + { + "key": [ + 206, + 45, + 40, + 158, + 32, + 199, + 111, + 117, + 193, + 53, + 200, + 17, + 141, + 92, + 191, + 95, + 40, + 40, + 2, + 111, + 11, + 99, + 149, + 136, + 163, + 235, + 74, + 215, + 82, + 206, + 165, + 72 + ], + "nonce": [ + 187, + 8, + 82, + 109, + 216, + 189, + 28, + 59, + 181, + 141, + 9, + 153 + ], + "aad": [], + "plaintext": [ + 86, + 245, + 219, + 30, + 121, + 106, + 12, + 70, + 51, + 168, + 213, + 112, + 24, + 44, + 57, + 227, + 200, + 69, + 30, + 123, + 164, + 133, + 185, + 141, + 56, + 162, + 201, + 38, + 161, + 185, + 42, + 70 + ], + "ciphertext": [ + 164, + 16, + 5, + 223, + 24, + 115, + 77, + 79, + 63, + 153, + 241, + 158, + 248, + 252, + 67, + 177, + 110, + 244, + 49, + 32, + 124, + 176, + 70, + 99, + 65, + 191, + 22, + 75, + 88, + 226, + 53, + 51 + ], + "tag": [ + 164, + 92, + 42, + 30, + 246, + 174, + 199, + 92, + 194, + 45, + 113, + 128, + 125, + 171, + 60, + 39 + ] + }, + { + "key": [ + 102, + 228, + 24, + 208, + 236, + 151, + 180, + 32, + 177, + 181, + 54, + 93, + 27, + 109, + 92, + 215, + 197, + 172, + 26, + 86, + 83, + 115, + 145, + 32, + 212, + 174, + 195, + 201, + 76, + 147, + 194, + 135 + ], + "nonce": [ + 152, + 159, + 148, + 72, + 2, + 102, + 227, + 101, + 36, + 136, + 24, + 78 + ], + "aad": [], + "plaintext": [ + 229, + 5, + 43, + 25, + 215, + 248, + 39, + 253, + 96, + 244, + 92, + 137, + 37, + 128, + 159, + 210, + 33, + 126, + 196, + 209, + 106, + 168, + 155, + 191, + 149, + 200, + 106, + 28, + 30, + 66, + 189, + 54 + ], + "ciphertext": [ + 243, + 65, + 99, + 5, + 116, + 238, + 146, + 148, + 44, + 244, + 197, + 236, + 211, + 114, + 26, + 231, + 75, + 50, + 197, + 87, + 55, + 157, + 254, + 131, + 81, + 189, + 28, + 102, + 97, + 162, + 64, + 218 + ], + "tag": [ + 232, + 95, + 182, + 85, + 239, + 67, + 46, + 25, + 88, + 14, + 4, + 38, + 221, + 64, + 90, + 62 + ] + }, + { + "key": [ + 55, + 204, + 219, + 161, + 217, + 41, + 214, + 67, + 108, + 22, + 187, + 165, + 181, + 255, + 52, + 222, + 236, + 136, + 237, + 125, + 243, + 209, + 93, + 15, + 77, + 223, + 128, + 192, + 199, + 49, + 238, + 31 + ], + "nonce": [ + 92, + 27, + 33, + 200, + 153, + 142, + 214, + 41, + 144, + 6, + 211, + 249 + ], + "aad": [ + 34, + 237, + 35, + 89, + 70, + 35, + 90, + 133, + 164, + 91, + 197, + 250, + 215, + 20, + 11, + 250 + ], + "plaintext": [ + 173, + 66, + 96, + 227, + 205, + 199, + 107, + 204, + 16, + 199, + 178, + 192, + 107, + 128, + 179, + 190, + 148, + 130, + 88, + 229, + 239, + 32, + 197, + 8, + 168, + 31, + 81, + 233, + 106, + 81, + 131, + 136 + ], + "ciphertext": [ + 59, + 51, + 95, + 139, + 8, + 211, + 60, + 205, + 202, + 210, + 40, + 167, + 71, + 0, + 241, + 0, + 117, + 66, + 164, + 209, + 231, + 252, + 30, + 190, + 63, + 68, + 127, + 231, + 26, + 242, + 152, + 22 + ], + "tag": [ + 31, + 191, + 73, + 204, + 70, + 244, + 88, + 191, + 110, + 136, + 246, + 55, + 9, + 117, + 230, + 212 + ] + }, + { + "key": [ + 44, + 17, + 71, + 14, + 111, + 19, + 107, + 236, + 115, + 53, + 22, + 25, + 40, + 143, + 129, + 159, + 178, + 187, + 186, + 69, + 24, + 87, + 170, + 223, + 183, + 131, + 132, + 7, + 70, + 18, + 119, + 138 + ], + "nonce": [ + 78, + 108, + 194, + 188, + 193, + 90, + 70, + 213, + 30, + 136, + 149, + 141 + ], + "aad": [ + 5, + 210, + 147, + 105, + 146, + 47, + 218, + 193, + 167, + 179, + 127, + 7, + 149, + 63, + 225, + 117 + ], + "plaintext": [ + 59, + 49, + 134, + 160, + 36, + 117, + 245, + 54, + 216, + 13, + 139, + 211, + 38, + 236, + 200, + 179, + 61, + 208, + 79, + 102, + 248, + 186, + 29, + 32, + 145, + 121, + 82, + 65, + 11, + 5, + 194, + 237 + ], + "ciphertext": [ + 99, + 128, + 148, + 90, + 8, + 151, + 126, + 135, + 178, + 148, + 185, + 228, + 18, + 162, + 106, + 235, + 238, + 184, + 150, + 12, + 81, + 36, + 57, + 186, + 195, + 102, + 54, + 118, + 60, + 217, + 28, + 12 + ], + "tag": [ + 16, + 41, + 163, + 196, + 190, + 29, + 144, + 18, + 60, + 27, + 64, + 69, + 19, + 239, + 222, + 83 + ] + }, + { + "key": [ + 223, + 37, + 234, + 55, + 124, + 120, + 77, + 116, + 56, + 70, + 85, + 90, + 16, + 207, + 170, + 4, + 73, + 54, + 83, + 86, + 73, + 233, + 77, + 162, + 24, + 17, + 186, + 217, + 206, + 169, + 87, + 181 + ], + "nonce": [ + 53, + 245, + 248, + 233, + 80, + 193, + 245, + 122, + 211, + 223, + 177, + 250 + ], + "aad": [ + 40, + 235, + 70, + 119, + 17, + 12, + 203, + 110, + 220, + 141, + 32, + 19, + 220, + 143, + 70, + 236 + ], + "plaintext": [ + 152, + 148, + 26, + 128, + 122, + 200, + 241, + 110, + 239, + 11, + 61, + 60, + 123, + 189, + 253, + 85, + 208, + 23, + 54, + 197, + 179, + 54, + 13, + 146, + 180, + 53, + 138, + 90, + 137, + 25, + 56, + 11 + ], + "ciphertext": [ + 36, + 160, + 117, + 50, + 233, + 129, + 170, + 243, + 16, + 110, + 171, + 141, + 251, + 178, + 210, + 7, + 131, + 66, + 226, + 234, + 238, + 2, + 126, + 20, + 143, + 6, + 172, + 166, + 143, + 106, + 28, + 80 + ], + "tag": [ + 19, + 19, + 115, + 237, + 74, + 14, + 63, + 88, + 74, + 233, + 120, + 212, + 45, + 170, + 111, + 58 + ] + }, + { + "key": [ + 16, + 97, + 104, + 234, + 101, + 31, + 34, + 197, + 65, + 150, + 160, + 111, + 26, + 16, + 188, + 244, + 230, + 32, + 217, + 62, + 77, + 192, + 130, + 77, + 121, + 143, + 68, + 249, + 33, + 156, + 97, + 119 + ], + "nonce": [ + 64, + 100, + 220, + 189, + 99, + 28, + 242, + 11, + 5, + 174, + 34, + 222 + ], + "aad": [ + 163, + 110, + 47, + 185, + 205, + 150, + 168, + 202, + 154, + 226, + 177, + 147, + 170, + 73, + 142, + 253 + ], + "plaintext": [ + 176, + 211, + 218, + 43, + 150, + 184, + 136, + 156, + 146, + 228, + 69, + 171, + 190, + 164, + 198, + 208, + 213, + 212, + 77, + 127, + 188, + 199, + 218, + 222, + 76, + 146, + 246, + 188, + 221, + 191, + 6, + 225 + ], + "ciphertext": [ + 245, + 90, + 109, + 138, + 105, + 101, + 234, + 69, + 22, + 55, + 190, + 199, + 84, + 140, + 251, + 31, + 254, + 89, + 252, + 12, + 230, + 234, + 106, + 147, + 124, + 181, + 221, + 50, + 179, + 212, + 93, + 95 + ], + "tag": [ + 141, + 27, + 242, + 113, + 80, + 65, + 248, + 23, + 241, + 22, + 49, + 252, + 153, + 16, + 198, + 41 + ] + }, + { + "key": [ + 39, + 45, + 22, + 73, + 163, + 221, + 128, + 77, + 224, + 150, + 45, + 62, + 7, + 6, + 74, + 112, + 84, + 192, + 10, + 98, + 52, + 171, + 27, + 12, + 220, + 246, + 133, + 171, + 57, + 72, + 55, + 229 + ], + "nonce": [ + 149, + 91, + 88, + 151, + 246, + 185, + 128, + 107, + 190, + 197, + 195, + 62 + ], + "aad": [ + 51, + 230, + 24, + 236, + 187, + 229, + 235, + 5, + 102, + 223, + 33, + 195, + 195, + 75, + 126, + 37 + ], + "plaintext": [ + 54, + 229, + 124, + 41, + 192, + 140, + 81, + 173, + 127, + 169, + 28, + 4, + 22, + 249, + 118, + 207, + 208, + 17, + 120, + 14, + 180, + 76, + 197, + 171, + 211, + 76, + 123, + 67, + 27, + 9, + 59, + 141 + ], + "ciphertext": [ + 205, + 106, + 235, + 52, + 80, + 129, + 220, + 11, + 178, + 200, + 180, + 209, + 155, + 40, + 6, + 88, + 251, + 135, + 192, + 242, + 189, + 15, + 76, + 157, + 166, + 148, + 220, + 31, + 238, + 179, + 47, + 78 + ], + "tag": [ + 221, + 55, + 234, + 198, + 189, + 106, + 77, + 54, + 24, + 36, + 23, + 56, + 119, + 151, + 53, + 215 + ] + }, + { + "key": [ + 61, + 171, + 106, + 81, + 187, + 122, + 243, + 52, + 221, + 75, + 121, + 167, + 209, + 57, + 85, + 12, + 136, + 240, + 119, + 141, + 67, + 194, + 31, + 196, + 173, + 51, + 249, + 131, + 161, + 53, + 21, + 203 + ], + "nonce": [ + 54, + 46, + 170, + 103, + 202, + 179, + 209, + 237, + 72, + 233, + 243, + 136 + ], + "aad": [ + 82, + 133, + 33, + 80, + 120, + 110, + 101, + 71, + 162, + 97, + 142, + 21, + 199, + 113, + 16, + 182 + ], + "plaintext": [ + 62, + 183, + 245, + 240, + 164, + 202, + 154, + 167, + 0, + 4, + 151, + 96, + 44, + 97, + 36, + 67, + 58, + 96, + 168, + 252, + 217, + 27, + 32, + 23, + 91, + 78, + 232, + 126, + 107, + 16, + 162, + 215 + ], + "ciphertext": [ + 204, + 51, + 22, + 4, + 27, + 136, + 115, + 56, + 57, + 36, + 155, + 117, + 111, + 250, + 0, + 187, + 236, + 98, + 17, + 148, + 47, + 96, + 79, + 38, + 196, + 163, + 94, + 211, + 46, + 110, + 234, + 255 + ], + "tag": [ + 89, + 54, + 197, + 80, + 2, + 64, + 213, + 12, + 13, + 160, + 252, + 220, + 36, + 143, + 23, + 110 + ] + }, + { + "key": [ + 14, + 166, + 6, + 82, + 27, + 147, + 93, + 91, + 75, + 102, + 223, + 137, + 251, + 55, + 45, + 53, + 196, + 214, + 210, + 192, + 55, + 103, + 54, + 126, + 56, + 222, + 13, + 76, + 39, + 118, + 29, + 86 + ], + "nonce": [ + 13, + 49, + 104, + 49, + 138, + 79, + 118, + 57, + 38, + 153, + 100, + 11 + ], + "aad": [ + 59, + 216, + 132, + 144, + 112, + 207, + 3, + 76, + 66, + 152, + 244, + 15, + 51, + 176, + 184, + 57 + ], + "plaintext": [ + 244, + 80, + 179, + 109, + 108, + 73, + 65, + 24, + 151, + 188, + 227, + 144, + 1, + 215, + 63, + 240, + 27, + 94, + 133, + 102, + 23, + 158, + 54, + 218, + 202, + 199, + 6, + 76, + 171, + 92, + 98, + 112 + ], + "ciphertext": [ + 59, + 21, + 250, + 209, + 135, + 38, + 196, + 234, + 167, + 5, + 2, + 179, + 243, + 179, + 44, + 80, + 146, + 209, + 217, + 40, + 53, + 230, + 70, + 6, + 101, + 252, + 80, + 221, + 169, + 83, + 161, + 145 + ], + "tag": [ + 17, + 253, + 63, + 221, + 246, + 30, + 1, + 12, + 23, + 251, + 237, + 212, + 189, + 95, + 176, + 18 + ] + }, + { + "key": [ + 200, + 196, + 249, + 224, + 189, + 40, + 158, + 241, + 189, + 22, + 16, + 74, + 128, + 116, + 251, + 7, + 61, + 217, + 3, + 90, + 185, + 55, + 171, + 7, + 111, + 181, + 128, + 30, + 34, + 149, + 170, + 47 + ], + "nonce": [ + 190, + 105, + 157, + 157, + 152, + 236, + 31, + 114, + 77, + 168, + 189, + 15 + ], + "aad": [ + 169, + 133, + 199, + 72, + 151, + 50, + 3, + 140, + 49, + 144, + 203, + 82, + 190, + 35, + 115, + 124 + ], + "plaintext": [ + 73, + 254, + 148, + 7, + 167, + 25, + 212, + 30, + 101, + 133, + 135, + 128, + 156, + 254, + 215, + 165, + 180, + 153, + 65, + 194, + 214, + 55, + 143, + 60, + 10, + 254, + 97, + 47, + 84, + 240, + 88, + 161 + ], + "ciphertext": [ + 23, + 169, + 170, + 166, + 163, + 198, + 139, + 161, + 246, + 203, + 38, + 253, + 214, + 83, + 108, + 32, + 126, + 60, + 156, + 229, + 143, + 67, + 228, + 236, + 253, + 56, + 211, + 56, + 122, + 121, + 138, + 15 + ], + "tag": [ + 216, + 50, + 203, + 72, + 20, + 20, + 37, + 98, + 254, + 223, + 228, + 91, + 54, + 18, + 108, + 184 + ] + }, + { + "key": [ + 82, + 208, + 242, + 11, + 12, + 167, + 166, + 249, + 229, + 197, + 184, + 84, + 157, + 89, + 16, + 241, + 181, + 179, + 68, + 252, + 104, + 82, + 57, + 47, + 152, + 53, + 88, + 227, + 197, + 147, + 190, + 36 + ], + "nonce": [ + 213, + 198, + 24, + 169, + 64, + 165, + 165, + 217, + 204, + 129, + 63, + 39 + ], + "aad": [ + 97, + 130, + 63, + 126, + 57, + 237, + 118, + 20, + 60, + 167, + 36, + 157, + 20, + 155, + 223, + 87 + ], + "plaintext": [ + 169, + 254, + 216, + 162, + 147, + 85, + 104, + 83, + 33, + 249, + 120, + 229, + 156, + 64, + 19, + 83, + 9, + 48, + 108, + 212, + 27, + 37, + 52, + 159, + 230, + 113, + 220, + 121, + 144, + 149, + 28, + 104 + ], + "ciphertext": [ + 80, + 156, + 84, + 14, + 85, + 141, + 11, + 240, + 163, + 183, + 118, + 205, + 223, + 191, + 221, + 193, + 84, + 134, + 116, + 138, + 127, + 153, + 82, + 177, + 124, + 28, + 189, + 104, + 105, + 194, + 99, + 244 + ], + "tag": [ + 66, + 227, + 94, + 227, + 247, + 17, + 159, + 135, + 251, + 82, + 181, + 215, + 91, + 138, + 184, + 236 + ] + }, + { + "key": [ + 93, + 41, + 26, + 143, + 26, + 100, + 51, + 164, + 16, + 118, + 112, + 45, + 157, + 138, + 140, + 25, + 110, + 70, + 69, + 80, + 237, + 144, + 12, + 232, + 194, + 163, + 111, + 77, + 16, + 72, + 57, + 84 + ], + "nonce": [ + 196, + 186, + 116, + 62, + 230, + 146, + 229, + 208, + 11, + 90, + 226, + 198 + ], + "aad": [ + 135, + 143, + 166, + 114, + 10, + 179, + 14, + 2, + 135, + 246, + 144, + 58, + 205, + 45, + 202, + 25 + ], + "plaintext": [ + 96, + 93, + 81, + 155, + 38, + 24, + 36, + 88, + 254, + 166, + 141, + 221, + 216, + 96, + 51, + 57, + 15, + 197, + 69, + 248, + 67, + 174, + 129, + 120, + 80, + 162, + 164, + 87, + 74, + 221, + 1, + 93 + ], + "ciphertext": [ + 28, + 47, + 21, + 63, + 35, + 116, + 211, + 148, + 92, + 202, + 151, + 87, + 220, + 24, + 217, + 161, + 90, + 147, + 39, + 101, + 38, + 40, + 90, + 110, + 49, + 110, + 227, + 42, + 114, + 9, + 44, + 52 + ], + "tag": [ + 231, + 144, + 94, + 133, + 108, + 136, + 198, + 236, + 228, + 187, + 71, + 120, + 27, + 236, + 249, + 35 + ] + }, + { + "key": [ + 9, + 226, + 114, + 77, + 64, + 23, + 205, + 87, + 233, + 103, + 0, + 14, + 77, + 162, + 205, + 92, + 92, + 24, + 204, + 251, + 6, + 195, + 59, + 124, + 230, + 42, + 118, + 65, + 228, + 187, + 11, + 115 + ], + "nonce": [ + 158, + 161, + 139, + 66, + 10, + 16, + 23, + 114, + 137, + 171, + 55, + 11 + ], + "aad": [ + 168, + 231, + 121, + 57, + 66, + 61, + 88, + 148, + 211, + 7, + 253, + 96, + 39, + 141, + 22, + 42 + ], + "plaintext": [ + 111, + 93, + 250, + 134, + 213, + 223, + 79, + 235, + 215, + 82, + 38, + 92, + 86, + 57, + 0, + 73, + 231, + 205, + 166, + 12, + 38, + 68, + 200, + 74, + 180, + 19, + 147, + 47, + 170, + 209, + 91, + 21 + ], + "ciphertext": [ + 53, + 227, + 122, + 155, + 145, + 62, + 181, + 139, + 114, + 38, + 46, + 146, + 215, + 88, + 77, + 68, + 191, + 154, + 132, + 66, + 241, + 178, + 243, + 218, + 58, + 93, + 5, + 236, + 106, + 42, + 49, + 226 + ], + "tag": [ + 26, + 149, + 2, + 59, + 26, + 74, + 62, + 136, + 85, + 32, + 236, + 121, + 225, + 163, + 174, + 249 + ] + }, + { + "key": [ + 133, + 68, + 169, + 244, + 246, + 192, + 239, + 223, + 243, + 218, + 144, + 207, + 163, + 238, + 83, + 251, + 225, + 248, + 222, + 21, + 157, + 41, + 83, + 124, + 128, + 62, + 22, + 81, + 218, + 21, + 55, + 24 + ], + "nonce": [ + 190, + 64, + 96, + 41, + 161, + 208, + 194, + 93, + 9, + 175, + 148, + 207 + ], + "aad": [ + 89, + 157, + 187, + 115, + 137, + 125, + 4, + 90, + 27, + 216, + 115, + 133, + 230, + 3, + 35, + 162 + ], + "plaintext": [ + 126, + 136, + 166, + 86, + 70, + 237, + 19, + 139, + 124, + 116, + 147, + 102, + 209, + 110, + 65, + 219, + 175, + 217, + 152, + 122, + 210, + 55, + 59, + 185, + 208, + 182, + 206, + 12, + 26, + 77, + 102, + 97 + ], + "ciphertext": [ + 56, + 255, + 191, + 159, + 255, + 248, + 214, + 169, + 32, + 144, + 88, + 78, + 109, + 172, + 225, + 198, + 164, + 125, + 61, + 87, + 9, + 162, + 94, + 71, + 5, + 87, + 213, + 200, + 245, + 221, + 24, + 81 + ], + "tag": [ + 213, + 178, + 232, + 60, + 71, + 223, + 64, + 77, + 233, + 167, + 205, + 149, + 211, + 203, + 231, + 171 + ] + }, + { + "key": [ + 53, + 185, + 210, + 165, + 219, + 59, + 6, + 231, + 114, + 12, + 236, + 121, + 77, + 174, + 97, + 80, + 41, + 164, + 145, + 196, + 23, + 242, + 53, + 73, + 142, + 4, + 150, + 205, + 129, + 131, + 209, + 191 + ], + "nonce": [ + 179, + 130, + 152, + 121, + 22, + 225, + 151, + 82, + 221, + 158, + 204, + 12 + ], + "aad": [ + 224, + 170, + 58, + 31, + 29, + 246, + 1, + 54, + 108, + 89, + 163, + 144, + 244, + 240, + 108, + 59 + ], + "plaintext": [ + 118, + 178, + 144, + 73, + 105, + 1, + 197, + 130, + 74, + 209, + 103, + 67, + 61, + 187, + 109, + 107, + 88, + 86, + 212, + 25, + 19, + 238, + 151, + 236, + 129, + 231, + 12, + 246, + 161, + 112, + 227, + 92 + ], + "ciphertext": [ + 120, + 52, + 116, + 0, + 214, + 121, + 158, + 119, + 225, + 30, + 118, + 192, + 236, + 253, + 49, + 27, + 236, + 243, + 31, + 116, + 241, + 75, + 58, + 113, + 230, + 213, + 38, + 206, + 87, + 1, + 92, + 139 + ], + "tag": [ + 191, + 141, + 236, + 47, + 234, + 199, + 207, + 233, + 243, + 48, + 189, + 252, + 146, + 115, + 123, + 51 + ] + }, + { + "key": [ + 215, + 7, + 234, + 179, + 193, + 103, + 183, + 62, + 254, + 176, + 140, + 80, + 225, + 43, + 21, + 105, + 162, + 117, + 72, + 126, + 161, + 54, + 245, + 39, + 54, + 192, + 243, + 206, + 102, + 182, + 159, + 163 + ], + "nonce": [ + 17, + 17, + 111, + 52, + 24, + 46, + 82, + 66, + 134, + 66, + 231, + 71 + ], + "aad": [ + 174, + 159, + 144, + 51, + 24, + 0, + 195, + 88, + 113, + 108, + 146, + 102, + 127, + 121, + 247, + 72 + ], + "plaintext": [ + 160, + 196, + 129, + 131, + 98, + 3, + 91, + 22, + 181, + 13, + 228, + 69, + 213, + 88, + 234, + 92, + 248, + 132, + 75, + 245, + 200, + 75, + 150, + 35, + 41, + 153, + 162, + 39, + 152, + 6, + 204, + 69 + ], + "ciphertext": [ + 145, + 199, + 116, + 4, + 178, + 0, + 40, + 239, + 15, + 212, + 221, + 127, + 139, + 101, + 182, + 89, + 74, + 249, + 74, + 30, + 127, + 199, + 156, + 251, + 219, + 16, + 130, + 101, + 53, + 79, + 199, + 27 + ], + "tag": [ + 108, + 52, + 16, + 212, + 185, + 21, + 219, + 173, + 116, + 87, + 21, + 32, + 44, + 4, + 233, + 164 + ] + }, + { + "key": [ + 64, + 93, + 19, + 238, + 72, + 211, + 185, + 252, + 38, + 188, + 252, + 167, + 118, + 178, + 175, + 108, + 116, + 93, + 143, + 195, + 65, + 113, + 98, + 47, + 140, + 108, + 75, + 229, + 165, + 75, + 139, + 101 + ], + "nonce": [ + 173, + 209, + 82, + 74, + 187, + 27, + 132, + 111, + 15, + 101, + 119, + 218 + ], + "aad": [ + 11, + 28, + 76, + 59, + 168, + 119, + 188, + 165, + 132, + 107, + 44, + 31, + 43, + 14, + 33, + 5 + ], + "plaintext": [ + 224, + 100, + 117, + 153, + 13, + 110, + 57, + 144, + 38, + 109, + 225, + 189, + 2, + 92, + 59, + 25, + 16, + 192, + 115, + 108, + 129, + 5, + 8, + 133, + 242, + 191, + 193, + 62, + 199, + 142, + 157, + 150 + ], + "ciphertext": [ + 99, + 153, + 247, + 230, + 214, + 198, + 128, + 252, + 65, + 186, + 200, + 190, + 227, + 131, + 107, + 154, + 66, + 65, + 64, + 61, + 90, + 25, + 228, + 145, + 159, + 57, + 108, + 227, + 123, + 35, + 141, + 56 + ], + "tag": [ + 231, + 84, + 244, + 0, + 215, + 108, + 118, + 224, + 60, + 99, + 234, + 136, + 207, + 100, + 204, + 186 + ] + }, + { + "key": [ + 88, + 83, + 192, + 32, + 148, + 107, + 53, + 242, + 197, + 142, + 196, + 39, + 21, + 43, + 132, + 4, + 32, + 196, + 0, + 41, + 99, + 106, + 220, + 187, + 2, + 116, + 113, + 55, + 140, + 253, + 222, + 15 + ], + "nonce": [ + 238, + 195, + 19, + 221, + 7, + 204, + 27, + 62, + 107, + 6, + 138, + 71 + ], + "aad": [ + 19, + 137, + 181, + 34, + 194, + 74, + 119, + 65, + 129, + 112, + 5, + 83, + 240, + 36, + 107, + 186, + 189, + 211, + 141, + 111 + ], + "plaintext": [ + 206, + 116, + 88, + 229, + 106, + 239, + 144, + 97, + 203, + 12, + 66, + 236, + 35, + 21, + 86, + 94, + 97, + 104, + 245, + 166, + 36, + 159, + 253, + 49, + 97, + 11, + 109, + 23, + 171, + 100, + 147, + 94 + ], + "ciphertext": [ + 234, + 220, + 59, + 135, + 102, + 167, + 125, + 237, + 26, + 88, + 203, + 114, + 126, + 202, + 42, + 151, + 144, + 73, + 108, + 41, + 134, + 84, + 205, + 167, + 143, + 235, + 240, + 218, + 22, + 182, + 144, + 59 + ], + "tag": [ + 61, + 73, + 165, + 179, + 47, + 222, + 126, + 175, + 204, + 233, + 0, + 121, + 33, + 127, + 251, + 87 + ] + }, + { + "key": [ + 80, + 25, + 172, + 6, + 23, + 254, + 161, + 5, + 23, + 162, + 162, + 113, + 78, + 108, + 211, + 105, + 198, + 129, + 190, + 52, + 12, + 42, + 36, + 97, + 19, + 6, + 237, + 205, + 157, + 92, + 57, + 40 + ], + "nonce": [ + 253, + 31, + 166, + 181, + 202, + 185, + 170, + 141, + 86, + 65, + 138, + 187 + ], + "aad": [ + 149, + 59, + 203, + 215, + 49, + 161, + 57, + 197, + 222, + 58, + 43, + 117, + 233, + 255, + 164, + 244, + 128, + 24, + 38, + 106 + ], + "plaintext": [ + 67, + 73, + 34, + 31, + 102, + 71, + 169, + 6, + 164, + 126, + 100, + 181, + 167, + 161, + 222, + 178, + 247, + 202, + 245, + 195, + 254, + 241, + 111, + 11, + 150, + 141, + 98, + 91, + 202, + 54, + 61, + 202 + ], + "ciphertext": [ + 219, + 206, + 101, + 5, + 8, + 218, + 181, + 244, + 153, + 118, + 118, + 81, + 238, + 115, + 70, + 146, + 247, + 177, + 87, + 52, + 25, + 119, + 105, + 45, + 44, + 168, + 121, + 121, + 158, + 143, + 84, + 170 + ], + "tag": [ + 32, + 35, + 158, + 151, + 226, + 219, + 73, + 133, + 240, + 126, + 39, + 27, + 165, + 69, + 187, + 191 + ] + }, + { + "key": [ + 200, + 206, + 233, + 10, + 139, + 154, + 214, + 9, + 77, + 70, + 158, + 93, + 30, + 220, + 48, + 214, + 103, + 96, + 142, + 137, + 178, + 98, + 0, + 202, + 199, + 126, + 253, + 126, + 82, + 175, + 54, + 253 + ], + "nonce": [ + 90, + 26, + 169, + 200, + 230, + 53, + 40, + 30, + 225, + 251, + 157, + 247 + ], + "aad": [ + 5, + 56, + 179, + 182, + 77, + 167, + 42, + 172, + 89, + 27, + 197, + 153, + 145, + 161, + 64, + 239, + 242, + 6, + 179, + 247 + ], + "plaintext": [ + 114, + 141, + 146, + 33, + 137, + 27, + 215, + 92, + 142, + 96, + 183, + 221, + 111, + 83, + 237, + 207, + 209, + 171, + 28, + 235, + 198, + 58, + 108, + 229, + 75, + 226, + 32, + 181, + 179, + 98, + 35, + 59 + ], + "ciphertext": [ + 183, + 83, + 235, + 107, + 135, + 240, + 200, + 119, + 140, + 62, + 163, + 167, + 79, + 186, + 59, + 49, + 206, + 214, + 210, + 218, + 148, + 212, + 61, + 72, + 42, + 176, + 67, + 24, + 6, + 168, + 13, + 117 + ], + "tag": [ + 178, + 29, + 41, + 207, + 111, + 208, + 69, + 113, + 255, + 202, + 243, + 23, + 211, + 132, + 223, + 17 + ] + }, + { + "key": [ + 180, + 183, + 119, + 16, + 248, + 111, + 253, + 70, + 63, + 193, + 75, + 185, + 234, + 164, + 66, + 75, + 43, + 58, + 88, + 23, + 120, + 229, + 81, + 26, + 9, + 74, + 8, + 251, + 32, + 76, + 171, + 89 + ], + "nonce": [ + 62, + 75, + 18, + 191, + 85, + 99, + 59, + 244, + 141, + 16, + 70, + 32 + ], + "aad": [ + 62, + 59, + 76, + 147, + 105, + 38, + 98, + 102, + 9, + 131, + 38, + 33, + 123, + 86, + 119, + 164, + 2, + 151, + 203, + 135 + ], + "plaintext": [ + 111, + 68, + 168, + 223, + 17, + 220, + 226, + 125, + 240, + 117, + 234, + 16, + 221, + 235, + 117, + 102, + 202, + 108, + 152, + 138, + 51, + 76, + 245, + 110, + 133, + 64, + 247, + 17, + 102, + 215, + 192, + 209 + ], + "ciphertext": [ + 49, + 248, + 47, + 92, + 177, + 205, + 92, + 75, + 72, + 25, + 182, + 26, + 169, + 55, + 122, + 190, + 190, + 143, + 202, + 118, + 151, + 139, + 17, + 153, + 23, + 132, + 98, + 199, + 193, + 196, + 226, + 178 + ], + "tag": [ + 27, + 58, + 83, + 87, + 104, + 232, + 72, + 13, + 117, + 236, + 145, + 178, + 231, + 181, + 94, + 253 + ] + }, + { + "key": [ + 10, + 143, + 183, + 84, + 152, + 161, + 57, + 34, + 60, + 118, + 61, + 82, + 187, + 227, + 212, + 47, + 129, + 61, + 227, + 112, + 250, + 54, + 184, + 30, + 220, + 69, + 83, + 212, + 33, + 157, + 45, + 93 + ], + "nonce": [ + 125, + 108, + 182, + 117, + 253, + 237, + 62, + 254, + 249, + 8, + 161, + 26 + ], + "aad": [ + 35, + 20, + 173, + 134, + 178, + 72, + 241, + 237, + 40, + 120, + 231, + 197, + 98, + 181, + 51, + 191, + 45, + 218, + 90, + 41 + ], + "plaintext": [ + 129, + 182, + 156, + 163, + 84, + 222, + 59, + 4, + 215, + 110, + 230, + 35, + 52, + 203, + 152, + 30, + 85, + 240, + 33, + 15, + 17, + 116, + 211, + 145, + 101, + 93, + 15, + 103, + 18, + 146, + 26, + 14 + ], + "ciphertext": [ + 106, + 35, + 211, + 7, + 55, + 244, + 167, + 43, + 30, + 7, + 186, + 35, + 209, + 127, + 222, + 67, + 164, + 73, + 142, + 46, + 96, + 211, + 225, + 176, + 200, + 230, + 234, + 38, + 162, + 187, + 51, + 26 + ], + "tag": [ + 127, + 202, + 196, + 66, + 251, + 101, + 121, + 16, + 198, + 42, + 116, + 177, + 208, + 99, + 137, + 2 + ] + }, + { + "key": [ + 168, + 67, + 21, + 5, + 136, + 73, + 105, + 12, + 43, + 136, + 6, + 42, + 239, + 129, + 19, + 77, + 51, + 133, + 38, + 186, + 167, + 9, + 14, + 134, + 95, + 202, + 173, + 148, + 187, + 245, + 28, + 165 + ], + "nonce": [ + 164, + 135, + 207, + 167, + 1, + 68, + 123, + 73, + 90, + 171, + 65, + 224 + ], + "aad": [ + 124, + 68, + 22, + 176, + 207, + 19, + 172, + 118, + 190, + 198, + 104, + 122, + 104, + 64, + 220, + 112, + 62, + 145, + 187, + 134 + ], + "plaintext": [ + 24, + 7, + 78, + 20, + 220, + 10, + 20, + 212, + 67, + 159, + 29, + 113, + 9, + 39, + 237, + 140, + 32, + 1, + 84, + 200, + 73, + 47, + 119, + 241, + 15, + 101, + 62, + 11, + 246, + 7, + 12, + 166 + ], + "ciphertext": [ + 128, + 244, + 11, + 126, + 51, + 93, + 64, + 252, + 88, + 89, + 232, + 127, + 56, + 94, + 20, + 121, + 138, + 37, + 56, + 24, + 232, + 173, + 115, + 177, + 121, + 156, + 20, + 25, + 99, + 130, + 70, + 164 + ], + "tag": [ + 180, + 199, + 199, + 109, + 136, + 99, + 231, + 132, + 235, + 96, + 41, + 205, + 22, + 14, + 246, + 222 + ] + }, + { + "key": [ + 130, + 131, + 59, + 202, + 174, + 197, + 111, + 106, + 187, + 179, + 55, + 143, + 125, + 101, + 218, + 246, + 230, + 246, + 242, + 160, + 209, + 232, + 88, + 199, + 33, + 159, + 83, + 167, + 132, + 15, + 78, + 0 + ], + "nonce": [ + 75, + 201, + 176, + 40, + 160, + 11, + 232, + 254, + 181, + 35, + 41, + 120 + ], + "aad": [ + 118, + 252, + 142, + 213, + 113, + 84, + 205, + 138, + 155, + 61, + 2, + 200, + 112, + 97, + 237, + 210, + 168, + 21, + 120, + 17 + ], + "plaintext": [ + 217, + 178, + 56, + 49, + 35, + 162, + 122, + 147, + 188, + 232, + 90, + 221, + 131, + 146, + 185, + 56, + 9, + 59, + 64, + 232, + 47, + 24, + 46, + 72, + 75, + 244, + 248, + 79, + 163, + 191, + 179, + 240 + ], + "ciphertext": [ + 56, + 62, + 254, + 151, + 20, + 56, + 205, + 43, + 44, + 187, + 57, + 157, + 116, + 163, + 251, + 62, + 237, + 211, + 148, + 241, + 134, + 42, + 221, + 197, + 142, + 159, + 221, + 76, + 66, + 20, + 2, + 210 + ], + "tag": [ + 253, + 128, + 60, + 79, + 169, + 23, + 247, + 255, + 100, + 154, + 106, + 172, + 1, + 58, + 150, + 177 + ] + }, + { + "key": [ + 238, + 70, + 52, + 196, + 156, + 86, + 114, + 198, + 96, + 150, + 138, + 66, + 134, + 38, + 152, + 246, + 193, + 178, + 199, + 183, + 158, + 253, + 22, + 5, + 194, + 74, + 248, + 255, + 159, + 248, + 54, + 108 + ], + "nonce": [ + 135, + 121, + 18, + 178, + 243, + 88, + 136, + 210, + 129, + 6, + 18, + 204 + ], + "aad": [ + 147, + 189, + 102, + 157, + 180, + 241, + 53, + 78, + 246, + 200, + 173, + 219, + 12, + 247, + 41, + 228, + 109, + 92, + 56, + 70 + ], + "plaintext": [ + 149, + 18, + 165, + 38, + 138, + 12, + 179, + 251, + 217, + 22, + 221, + 184, + 32, + 220, + 231, + 127, + 30, + 13, + 187, + 82, + 200, + 255, + 199, + 167, + 75, + 224, + 119, + 17, + 158, + 146, + 69, + 228 + ], + "ciphertext": [ + 105, + 175, + 10, + 201, + 84, + 224, + 214, + 144, + 67, + 133, + 29, + 137, + 241, + 83, + 142, + 188, + 180, + 39, + 105, + 133, + 126, + 186, + 39, + 219, + 228, + 173, + 79, + 214, + 15, + 215, + 85, + 55 + ], + "tag": [ + 62, + 228, + 67, + 135, + 62, + 47, + 127, + 126, + 166, + 1, + 254, + 61, + 126, + 82, + 17, + 226 + ] + }, + { + "key": [ + 68, + 47, + 75, + 188, + 70, + 132, + 51, + 65, + 30, + 73, + 72, + 106, + 21, + 197, + 238, + 213, + 119, + 245, + 0, + 115, + 128, + 255, + 18, + 109, + 153, + 116, + 243, + 189, + 63, + 228, + 227, + 196 + ], + "nonce": [ + 30, + 113, + 51, + 170, + 168, + 175, + 130, + 109, + 198, + 70, + 236, + 98 + ], + "aad": [ + 87, + 118, + 98, + 246, + 17, + 68, + 107, + 91, + 49, + 129, + 73, + 48, + 2, + 158, + 219, + 148, + 154, + 48, + 220, + 185 + ], + "plaintext": [ + 127, + 128, + 105, + 229, + 195, + 86, + 236, + 225, + 53, + 217, + 139, + 181, + 99, + 200, + 180, + 17, + 234, + 144, + 234, + 59, + 103, + 61, + 253, + 146, + 225, + 186, + 156, + 69, + 158, + 250, + 230, + 31 + ], + "ciphertext": [ + 185, + 98, + 149, + 39, + 80, + 235, + 43, + 206, + 49, + 62, + 26, + 133, + 167, + 46, + 60, + 156, + 194, + 234, + 126, + 88, + 195, + 83, + 234, + 55, + 223, + 44, + 159, + 7, + 35, + 153, + 92, + 167 + ], + "tag": [ + 230, + 51, + 254, + 159, + 16, + 206, + 223, + 15, + 13, + 2, + 170, + 45, + 220, + 244, + 125, + 134 + ] + }, + { + "key": [ + 58, + 41, + 174, + 192, + 9, + 244, + 79, + 221, + 43, + 27, + 192, + 124, + 183, + 131, + 111, + 41, + 216, + 88, + 151, + 116, + 189, + 13, + 116, + 8, + 154, + 104, + 217, + 230, + 120, + 39, + 214, + 216 + ], + "nonce": [ + 164, + 44, + 95, + 182, + 21, + 115, + 199, + 38, + 136, + 172, + 49, + 216 + ], + "aad": [ + 46, + 226, + 88, + 45, + 84, + 78, + 22, + 99, + 241, + 215, + 160, + 181, + 3, + 59, + 203, + 15, + 206, + 19, + 179, + 229 + ], + "plaintext": [ + 211, + 110, + 184, + 21, + 6, + 192, + 160, + 228, + 235, + 202, + 201, + 180, + 177, + 172, + 235, + 179, + 139, + 148, + 184, + 242, + 206, + 61, + 111, + 133, + 168, + 247, + 5, + 250, + 64, + 203, + 152, + 122 + ], + "ciphertext": [ + 23, + 158, + 244, + 73, + 218, + 170, + 203, + 150, + 31, + 136, + 195, + 155, + 68, + 87, + 214, + 99, + 143, + 48, + 71, + 98, + 189, + 105, + 89, + 36, + 202, + 158, + 189, + 1, + 163, + 233, + 155, + 159 + ], + "tag": [ + 31, + 238, + 23, + 108, + 122, + 93, + 33, + 71, + 72, + 225, + 212, + 123, + 119, + 244, + 188, + 200 + ] + }, + { + "key": [ + 237, + 71, + 102, + 0, + 84, + 41, + 79, + 60, + 145, + 60, + 151, + 184, + 105, + 49, + 124, + 189, + 220, + 57, + 93, + 117, + 123, + 239, + 125, + 41, + 184, + 204, + 189, + 210, + 197, + 78, + 153, + 211 + ], + "nonce": [ + 119, + 10, + 0, + 100, + 44, + 103, + 239, + 249, + 60, + 159, + 31, + 86 + ], + "aad": [ + 6, + 33, + 15, + 202, + 32, + 24, + 210, + 53, + 114, + 86, + 192, + 145, + 151, + 115, + 14, + 151, + 119, + 202, + 234, + 150 + ], + "plaintext": [ + 3, + 65, + 147, + 57, + 124, + 189, + 14, + 180, + 20, + 69, + 146, + 115, + 168, + 136, + 8, + 219, + 45, + 7, + 17, + 228, + 111, + 128, + 215, + 136, + 50, + 18, + 196, + 67, + 217, + 227, + 27, + 84 + ], + "ciphertext": [ + 106, + 37, + 14, + 189, + 51, + 144, + 34, + 157, + 70, + 182, + 145, + 20, + 39, + 67, + 219, + 161, + 196, + 50, + 192, + 254, + 170, + 15, + 13, + 209, + 157, + 12, + 228, + 230, + 168, + 145, + 141, + 128 + ], + "tag": [ + 165, + 246, + 233, + 117, + 89, + 43, + 71, + 41, + 7, + 195, + 75, + 147, + 191, + 198, + 157, + 222 + ] + }, + { + "key": [ + 149, + 57, + 132, + 68, + 147, + 54, + 45, + 195, + 249, + 19, + 48, + 143, + 126, + 18, + 162, + 160, + 224, + 42, + 253, + 189, + 136, + 105, + 135, + 123, + 48, + 206, + 3, + 151, + 251, + 3, + 73, + 220 + ], + "nonce": [ + 234, + 221, + 163, + 19, + 32, + 121, + 25, + 90, + 84, + 253, + 226, + 193 + ], + "aad": [ + 10, + 228, + 169, + 12, + 178, + 146, + 196, + 229, + 25, + 181, + 37, + 117, + 90, + 246, + 199, + 32, + 179, + 20, + 90, + 30 + ], + "plaintext": [ + 98, + 52, + 154, + 11, + 30, + 64, + 169, + 243, + 30, + 173, + 242, + 112, + 115, + 104, + 45, + 161, + 95, + 10, + 5, + 207, + 69, + 102, + 238, + 113, + 139, + 40, + 50, + 95, + 125, + 142, + 171, + 160 + ], + "ciphertext": [ + 173, + 108, + 149, + 33, + 191, + 120, + 209, + 217, + 86, + 115, + 237, + 209, + 80, + 242, + 184, + 221, + 40, + 241, + 6, + 37, + 214, + 127, + 162, + 95, + 31, + 180, + 45, + 19, + 43, + 167, + 252, + 250 + ], + "tag": [ + 145, + 98, + 66, + 169, + 203, + 128, + 223, + 252, + 182, + 211, + 174, + 5, + 194, + 120, + 129, + 154 + ] + }, + { + "key": [ + 59, + 78, + 176, + 141, + 39, + 174, + 11, + 119, + 96, + 90, + 230, + 40, + 161, + 181, + 74, + 84, + 2, + 2, + 101, + 80, + 103, + 159, + 171, + 10, + 32, + 117, + 43, + 238, + 81, + 13, + 61, + 146 + ], + "nonce": [ + 40, + 162, + 12, + 64, + 244, + 154, + 0, + 73, + 61, + 163, + 72, + 138 + ], + "aad": [ + 5, + 145, + 57, + 14, + 45, + 20, + 235, + 230, + 42, + 235, + 23, + 65, + 194, + 100, + 72, + 206, + 85, + 178, + 140, + 171 + ], + "plaintext": [ + 200, + 164, + 126, + 220, + 248, + 72, + 114, + 245, + 63, + 150, + 239, + 65, + 206, + 5, + 202, + 55, + 203, + 195, + 133, + 75, + 85, + 109, + 110, + 96, + 111, + 10, + 138, + 50, + 208, + 134, + 25, + 7 + ], + "ciphertext": [ + 163, + 232, + 203, + 248, + 77, + 248, + 82, + 152, + 56, + 247, + 147, + 21, + 199, + 241, + 160, + 183, + 187, + 58, + 212, + 196, + 208, + 54, + 236, + 49, + 123, + 24, + 16, + 178, + 116, + 238, + 48, + 128 + ], + "tag": [ + 10, + 143, + 102, + 218, + 235, + 127, + 10, + 136, + 117, + 105, + 9, + 196, + 233, + 63, + 205, + 54 + ] + }, + { + "key": [ + 12, + 204, + 234, + 143, + 31, + 108, + 225, + 65, + 105, + 14, + 36, + 108, + 244, + 203, + 159, + 53, + 182, + 107, + 175, + 110, + 105, + 134, + 184, + 224, + 180, + 207, + 221, + 19, + 252, + 219, + 200, + 195 + ], + "nonce": [ + 146, + 159, + 7, + 190, + 90, + 167, + 186, + 231, + 96, + 123, + 174, + 60 + ], + "aad": [ + 184, + 81, + 230, + 16, + 190, + 112, + 169, + 148, + 128, + 139, + 52, + 202, + 115, + 244, + 95, + 30, + 169, + 115, + 222, + 101 + ], + "plaintext": [ + 159, + 165, + 33, + 76, + 89, + 149, + 35, + 198, + 149, + 211, + 121, + 55, + 176, + 47, + 120, + 131, + 127, + 100, + 6, + 150, + 11, + 42, + 3, + 191, + 154, + 109, + 179, + 75, + 211, + 94, + 61, + 199 + ], + "ciphertext": [ + 145, + 126, + 204, + 139, + 0, + 181, + 63, + 127, + 176, + 115, + 45, + 102, + 132, + 138, + 16, + 110, + 145, + 246, + 10, + 207, + 45, + 207, + 24, + 8, + 50, + 167, + 77, + 89, + 147, + 198, + 88, + 218 + ], + "tag": [ + 41, + 89, + 226, + 7, + 70, + 187, + 182, + 171, + 102, + 223, + 210, + 155, + 148, + 119, + 121, + 154 + ] + }, + { + "key": [ + 236, + 191, + 174, + 242, + 52, + 91, + 52, + 243, + 31, + 191, + 109, + 104, + 239, + 179, + 133, + 229, + 131, + 61, + 248, + 182, + 230, + 174, + 98, + 30, + 222, + 2, + 186, + 249, + 115, + 93, + 45, + 186 + ], + "nonce": [ + 80, + 195, + 82, + 123, + 26, + 53, + 204, + 179, + 24, + 180, + 70, + 222 + ], + "aad": [ + 248, + 152, + 21, + 72, + 189, + 230, + 238, + 108, + 23, + 69, + 249, + 71, + 222, + 25, + 27, + 242, + 153, + 151, + 250, + 223 + ], + "plaintext": [ + 99, + 79, + 109, + 214, + 7, + 131, + 209, + 249, + 82, + 53, + 63, + 209, + 211, + 89, + 185, + 238, + 79, + 74, + 250, + 83, + 204, + 19, + 232, + 28, + 90, + 223, + 226, + 75, + 70, + 186, + 240, + 143 + ], + "ciphertext": [ + 112, + 94, + 95, + 103, + 171, + 136, + 155, + 162, + 56, + 17, + 142, + 63, + 217, + 185, + 11, + 104, + 190, + 128, + 25, + 149, + 174, + 48, + 115, + 120, + 217, + 59, + 80, + 151, + 124, + 249, + 5, + 136 + ], + "tag": [ + 18, + 209, + 68, + 104, + 172, + 24, + 204, + 153, + 54, + 189, + 86, + 95, + 138, + 212, + 45, + 13 + ] + }, + { + "key": [ + 220, + 119, + 111, + 1, + 86, + 193, + 93, + 3, + 38, + 35, + 133, + 75, + 98, + 92, + 97, + 134, + 142, + 93, + 184, + 75, + 123, + 111, + 159, + 189, + 54, + 114, + 241, + 47, + 0, + 37, + 224, + 246 + ], + "nonce": [ + 103, + 19, + 9, + 81, + 196, + 165, + 127, + 106, + 231, + 241, + 50, + 65 + ], + "aad": [ + 253, + 9, + 32, + 250, + 235, + 123, + 33, + 41, + 50, + 40, + 10, + 0, + 155, + 172, + 150, + 145, + 69, + 229, + 195, + 22, + 207, + 57, + 34, + 98, + 44, + 55, + 5, + 195, + 69, + 124, + 78, + 159, + 18, + 75, + 32, + 118, + 153, + 67, + 35, + 251, + 207, + 181, + 35, + 248, + 237, + 22, + 210, + 65 + ], + "plaintext": [ + 147, + 120, + 167, + 39, + 165, + 17, + 149, + 149, + 173, + 99, + 27, + 18, + 165, + 166, + 188, + 138, + 145, + 117, + 110, + 240, + 156, + 141, + 110, + 170, + 43, + 113, + 143, + 232, + 104, + 118, + 218, + 32 + ], + "ciphertext": [ + 109, + 149, + 140, + 32, + 135, + 13, + 64, + 26, + 60, + 31, + 122, + 10, + 192, + 146, + 201, + 119, + 116, + 212, + 81, + 192, + 159, + 122, + 174, + 153, + 42, + 136, + 65, + 255, + 10, + 185, + 214, + 13 + ], + "tag": [ + 184, + 118, + 131, + 27, + 78, + 205, + 114, + 66, + 150, + 59, + 4, + 10, + 164, + 92, + 65, + 20 + ] + }, + { + "key": [ + 7, + 179, + 184, + 115, + 93, + 103, + 160, + 86, + 50, + 197, + 87, + 7, + 106, + 196, + 18, + 147, + 245, + 37, + 64, + 186, + 192, + 82, + 21, + 115, + 232, + 192, + 65, + 78, + 195, + 111, + 114, + 32 + ], + "nonce": [ + 0, + 70, + 66, + 14, + 238, + 141, + 86, + 222, + 53, + 226, + 247, + 213 + ], + "aad": [ + 213, + 28, + 237, + 249, + 163, + 14, + 71, + 109, + 227, + 124, + 144, + 178, + 246, + 8, + 130, + 25, + 54, + 48, + 199, + 73, + 122, + 146, + 26, + 176, + 21, + 144, + 162, + 107, + 206, + 140, + 178, + 71, + 227, + 181, + 89, + 14, + 123, + 7, + 185, + 85, + 149, + 108, + 168, + 156, + 122, + 4, + 25, + 136 + ], + "plaintext": [ + 72, + 53, + 212, + 137, + 130, + 131, + 37, + 160, + 203, + 56, + 165, + 159, + 194, + 156, + 254, + 237, + 204, + 174, + 37, + 242, + 233, + 195, + 153, + 40, + 29, + 155, + 118, + 65, + 251, + 96, + 151, + 101 + ], + "ciphertext": [ + 70, + 235, + 49, + 205, + 152, + 182, + 204, + 62, + 202, + 254, + 28, + 209, + 252, + 45, + 69, + 250, + 105, + 54, + 103, + 203, + 211, + 167, + 210, + 197, + 248, + 193, + 2, + 150, + 130, + 126, + 168, + 60 + ], + "tag": [ + 54, + 205, + 78, + 118, + 221, + 6, + 121, + 136, + 116, + 119, + 191, + 185, + 108, + 241, + 197, + 246 + ] + }, + { + "key": [ + 2, + 25, + 241, + 75, + 156, + 166, + 80, + 108, + 19, + 136, + 23, + 124, + 74, + 230, + 238, + 100, + 173, + 42, + 192, + 37, + 110, + 187, + 248, + 194, + 25, + 180, + 13, + 246, + 232, + 87, + 29, + 112 + ], + "nonce": [ + 52, + 32, + 168, + 124, + 75, + 155, + 35, + 186, + 129, + 235, + 34, + 30 + ], + "aad": [ + 84, + 220, + 34, + 119, + 184, + 209, + 170, + 230, + 96, + 255, + 204, + 50, + 110, + 44, + 93, + 158, + 22, + 184, + 202, + 23, + 40, + 134, + 1, + 170, + 205, + 2, + 179, + 238, + 168, + 188, + 92, + 198, + 7, + 24, + 99, + 154, + 161, + 137, + 80, + 107, + 123, + 51, + 59, + 135, + 218, + 134, + 233, + 64 + ], + "plaintext": [ + 52, + 143, + 122, + 76, + 169, + 68, + 242, + 82, + 228, + 86, + 44, + 102, + 218, + 207, + 1, + 251, + 16, + 215, + 10, + 60, + 143, + 91, + 40, + 10, + 40, + 41, + 86, + 122, + 42, + 148, + 228, + 126 + ], + "ciphertext": [ + 88, + 201, + 33, + 25, + 191, + 182, + 173, + 83, + 227, + 135, + 202, + 198, + 114, + 140, + 231, + 59, + 130, + 225, + 143, + 110, + 91, + 251, + 252, + 165, + 245, + 172, + 195, + 112, + 205, + 140, + 118, + 164 + ], + "tag": [ + 231, + 249, + 227, + 227, + 218, + 230, + 208, + 163, + 71, + 13, + 143, + 89, + 114, + 145, + 24, + 12 + ] + }, + { + "key": [ + 135, + 68, + 14, + 231, + 246, + 254, + 191, + 62, + 20, + 239, + 10, + 145, + 122, + 135, + 197, + 214, + 18, + 96, + 254, + 252, + 151, + 158, + 234, + 234, + 192, + 166, + 70, + 98, + 201, + 140, + 180, + 247 + ], + "nonce": [ + 124, + 72, + 188, + 117, + 229, + 143, + 33, + 204, + 153, + 137, + 214, + 145 + ], + "aad": [ + 224, + 198, + 110, + 93, + 177, + 199, + 102, + 90, + 1, + 91, + 167, + 226, + 30, + 8, + 255, + 61, + 229, + 180, + 165, + 252, + 213, + 211, + 94, + 65, + 219, + 126, + 151, + 204, + 208, + 195, + 223, + 101, + 122, + 232, + 3, + 195, + 82, + 157, + 55, + 84, + 32, + 173, + 117, + 172, + 150, + 33, + 206, + 160 + ], + "plaintext": [ + 248, + 228, + 10, + 106, + 152, + 95, + 66, + 72, + 152, + 167, + 153, + 99, + 7, + 160, + 119, + 196, + 135, + 64, + 108, + 83, + 18, + 238, + 254, + 5, + 94, + 165, + 177, + 122, + 75, + 34, + 8, + 123 + ], + "ciphertext": [ + 90, + 17, + 143, + 195, + 219, + 218, + 246, + 188, + 148, + 144, + 211, + 114, + 183, + 98, + 58, + 247, + 109, + 167, + 132, + 27, + 249, + 130, + 10, + 156, + 102, + 36, + 161, + 94, + 255, + 106, + 105, + 194 + ], + "tag": [ + 13, + 220, + 42, + 224, + 135, + 217, + 184, + 202, + 34, + 73, + 234, + 90, + 163, + 219, + 212, + 199 + ] + }, + { + "key": [ + 177, + 36, + 37, + 121, + 111, + 99, + 191, + 84, + 53, + 116, + 15, + 144, + 57, + 250, + 102, + 54, + 127, + 199, + 112, + 45, + 103, + 92, + 97, + 178, + 222, + 196, + 67, + 95, + 238, + 234, + 7, + 248 + ], + "nonce": [ + 242, + 103, + 39, + 5, + 62, + 109, + 103, + 194, + 210, + 191, + 30, + 105 + ], + "aad": [ + 229, + 15, + 202, + 46, + 90, + 129, + 174, + 86, + 202, + 7, + 243, + 76, + 75, + 93, + 161, + 64, + 211, + 104, + 204, + 234, + 176, + 132, + 148, + 245, + 226, + 143, + 116, + 108, + 191, + 239, + 220, + 40, + 91, + 121, + 179, + 60, + 244, + 150, + 159, + 230, + 24, + 183, + 122, + 183, + 186, + 175, + 226, + 113 + ], + "plaintext": [ + 157, + 240, + 121, + 217, + 138, + 110, + 77, + 190, + 39, + 122, + 133, + 69, + 244, + 246, + 193, + 159, + 225, + 48, + 244, + 168, + 75, + 221, + 107, + 118, + 10, + 4, + 159, + 186, + 33, + 212, + 233, + 154 + ], + "ciphertext": [ + 132, + 95, + 0, + 32, + 46, + 46, + 137, + 69, + 22, + 216, + 244, + 164, + 2, + 20, + 48, + 229, + 49, + 150, + 112, + 152, + 201, + 169, + 64, + 36, + 199, + 17, + 60, + 154, + 27, + 145, + 200, + 205 + ], + "tag": [ + 53, + 102, + 199, + 89, + 103, + 174, + 0, + 25, + 142, + 57, + 235, + 233, + 240, + 172, + 105, + 127 + ] + }, + { + "key": [ + 103, + 77, + 251, + 98, + 91, + 139, + 12, + 225, + 218, + 219, + 187, + 203, + 247, + 225, + 81, + 197, + 178, + 206, + 207, + 10, + 27, + 196, + 224, + 127, + 71, + 52, + 243, + 166, + 121, + 35, + 80, + 205 + ], + "nonce": [ + 153, + 231, + 183, + 110, + 102, + 134, + 68, + 150, + 22, + 173, + 54, + 199 + ], + "aad": [ + 42, + 177, + 87, + 62, + 90, + 148, + 202, + 41, + 151, + 89, + 8, + 64, + 189, + 156, + 98, + 230, + 173, + 213, + 94, + 77, + 62, + 172, + 18, + 200, + 149, + 210, + 236, + 99, + 119, + 145, + 202, + 164, + 29, + 70, + 237, + 145, + 230, + 6, + 77, + 182, + 39, + 225, + 251, + 239, + 113, + 211, + 29, + 1 + ], + "plaintext": [ + 10, + 116, + 74, + 114, + 229, + 54, + 160, + 72, + 77, + 180, + 112, + 145, + 96, + 146, + 40, + 216, + 3, + 188, + 250, + 154, + 141, + 175, + 87, + 158, + 48, + 57, + 227, + 100, + 95, + 118, + 136, + 226 + ], + "ciphertext": [ + 229, + 80, + 238, + 119, + 6, + 151, + 9, + 245, + 25, + 155, + 227, + 198, + 24, + 242, + 164, + 23, + 142, + 77, + 113, + 154, + 183, + 61, + 244, + 28, + 191, + 227, + 44, + 82, + 119, + 113, + 56, + 255 + ], + "tag": [ + 19, + 74, + 195, + 250, + 139, + 212, + 175, + 126, + 232, + 54, + 244, + 163, + 66, + 29, + 158, + 153 + ] + }, + { + "key": [ + 16, + 193, + 222, + 95, + 116, + 21, + 96, + 218, + 229, + 190, + 35, + 225, + 86, + 73, + 240, + 17, + 77, + 181, + 41, + 73, + 86, + 11, + 182, + 205, + 242, + 212, + 136, + 50, + 71, + 57, + 46, + 225 + ], + "nonce": [ + 124, + 247, + 60, + 20, + 114, + 205, + 96, + 216, + 211, + 95, + 222, + 81 + ], + "aad": [ + 211, + 250, + 139, + 111, + 96, + 122, + 32, + 161, + 141, + 215, + 234, + 200, + 94, + 171, + 239, + 105, + 212, + 251, + 90, + 7, + 77, + 142, + 125, + 27, + 241, + 93, + 7, + 115, + 46, + 216, + 14, + 2, + 1, + 99, + 180, + 117, + 242, + 9, + 196, + 176, + 203, + 250, + 0, + 214, + 93, + 30, + 130, + 239 + ], + "plaintext": [ + 5, + 190, + 205, + 54, + 106, + 235, + 170, + 46, + 96, + 159, + 80, + 125, + 210, + 221, + 68, + 51, + 178, + 171, + 160, + 99, + 75, + 14, + 185, + 165, + 191, + 125, + 237, + 76, + 200, + 251, + 237, + 114 + ], + "ciphertext": [ + 40, + 15, + 12, + 48, + 110, + 26, + 58, + 171, + 143, + 249, + 171, + 62, + 74, + 154, + 220, + 46, + 154, + 228, + 228, + 225, + 160, + 111, + 25, + 13, + 17, + 179, + 180, + 220, + 66, + 128, + 228, + 243 + ], + "tag": [ + 59, + 200, + 190, + 132, + 91, + 245, + 255, + 132, + 76, + 7, + 51, + 124, + 44, + 253, + 95, + 128 + ] + }, + { + "key": [ + 232, + 214, + 171, + 94, + 81, + 70, + 69, + 221, + 126, + 5, + 27, + 2, + 143, + 91, + 254, + 98, + 76, + 114, + 244, + 79, + 48, + 39, + 149, + 119, + 54, + 90, + 234, + 101, + 212, + 168, + 168, + 25 + ], + "nonce": [ + 48, + 176, + 214, + 84, + 238, + 91, + 121, + 194, + 207, + 178, + 65, + 0 + ], + "aad": [ + 8, + 46, + 83, + 75, + 248, + 96, + 208, + 6, + 30, + 194, + 218, + 211, + 77, + 107, + 13, + 184, + 203, + 161, + 198, + 81, + 242, + 199, + 5, + 53, + 111, + 242, + 113, + 228, + 115, + 101, + 176, + 177, + 143, + 141, + 219, + 58, + 60, + 34, + 105, + 180, + 55, + 251, + 7, + 3, + 201, + 173, + 54, + 122 + ], + "plaintext": [ + 25, + 190, + 126, + 15, + 238, + 221, + 64, + 43, + 244, + 176, + 89, + 149, + 163, + 142, + 95, + 66, + 60, + 3, + 61, + 224, + 22, + 227, + 174, + 131, + 234, + 140, + 60, + 28, + 186, + 101, + 142, + 30 + ], + "ciphertext": [ + 133, + 115, + 128, + 12, + 115, + 125, + 36, + 128, + 178, + 136, + 92, + 231, + 20, + 172, + 106, + 21, + 242, + 50, + 135, + 177, + 209, + 41, + 73, + 163, + 215, + 110, + 255, + 190, + 130, + 181, + 147, + 189 + ], + "tag": [ + 80, + 17, + 8, + 132, + 41, + 33, + 81, + 245, + 18, + 19, + 204, + 178, + 254, + 147, + 77, + 136 + ] + }, + { + "key": [ + 45, + 30, + 175, + 94, + 98, + 202, + 128, + 253, + 21, + 21, + 168, + 17, + 192, + 228, + 192, + 69, + 171, + 168, + 199, + 105, + 223, + 3, + 213, + 127, + 116, + 147, + 235, + 98, + 62, + 216, + 185, + 65 + ], + "nonce": [ + 171, + 241, + 144, + 176, + 93, + 242, + 230, + 85, + 108, + 179, + 75, + 71 + ], + "aad": [ + 117, + 171, + 155, + 211, + 156, + 36, + 228, + 152, + 165, + 77, + 133, + 168, + 183, + 106, + 65, + 38, + 220, + 24, + 121, + 242, + 163, + 2, + 112, + 164, + 38, + 9, + 118, + 62, + 4, + 90, + 64, + 33, + 120, + 91, + 97, + 52, + 242, + 131, + 253, + 129, + 193, + 149, + 195, + 24, + 142, + 120, + 117, + 45 + ], + "plaintext": [ + 156, + 124, + 213, + 34, + 237, + 92, + 10, + 243, + 229, + 125, + 160, + 141, + 38, + 83, + 239, + 119, + 235, + 151, + 55, + 52, + 243, + 96, + 87, + 43, + 188, + 177, + 90, + 42, + 108, + 189, + 96, + 185 + ], + "ciphertext": [ + 95, + 223, + 218, + 204, + 177, + 5, + 229, + 64, + 140, + 55, + 90, + 248, + 202, + 99, + 166, + 122, + 250, + 186, + 124, + 203, + 205, + 89, + 26, + 204, + 169, + 168, + 109, + 146, + 249, + 47, + 208, + 247 + ], + "tag": [ + 73, + 148, + 11, + 118, + 16, + 97, + 139, + 58, + 92, + 179, + 145, + 35, + 57, + 224, + 107, + 60 + ] + }, + { + "key": [ + 182, + 2, + 6, + 119, + 224, + 152, + 197, + 158, + 25, + 234, + 207, + 38, + 115, + 36, + 115, + 216, + 67, + 170, + 253, + 107, + 249, + 153, + 199, + 7, + 187, + 8, + 171, + 137, + 100, + 6, + 145, + 141 + ], + "nonce": [ + 128, + 113, + 103, + 239, + 43, + 132, + 179, + 45, + 29, + 244, + 169, + 76 + ], + "aad": [ + 6, + 34, + 93, + 65, + 10, + 218, + 62, + 4, + 21, + 125, + 167, + 229, + 72, + 29, + 125, + 159, + 34, + 133, + 132, + 88, + 36, + 170, + 192, + 192, + 224, + 51, + 36, + 78, + 212, + 193, + 177, + 150, + 21, + 53, + 76, + 34, + 75, + 168, + 183, + 9, + 60, + 86, + 81, + 209, + 14, + 249, + 82, + 254 + ], + "plaintext": [ + 49, + 153, + 214, + 185, + 93, + 19, + 59, + 165, + 183, + 234, + 220, + 66, + 0, + 128, + 160, + 178, + 73, + 200, + 79, + 73, + 96, + 189, + 54, + 157, + 107, + 249, + 227, + 19, + 98, + 124, + 246, + 112 + ], + "ciphertext": [ + 70, + 24, + 173, + 191, + 165, + 234, + 78, + 226, + 96, + 227, + 16, + 20, + 11, + 56, + 82, + 50, + 183, + 195, + 173, + 70, + 136, + 122, + 162, + 16, + 127, + 125, + 175, + 255, + 216, + 92, + 218, + 34 + ], + "tag": [ + 45, + 118, + 48, + 123, + 245, + 88, + 38, + 223, + 235, + 88, + 161, + 113, + 182, + 250, + 128, + 228 + ] + }, + { + "key": [ + 247, + 84, + 86, + 196, + 145, + 141, + 11, + 234, + 114, + 245, + 70, + 169, + 161, + 226, + 219, + 11, + 106, + 185, + 188, + 217, + 120, + 43, + 94, + 177, + 194, + 112, + 14, + 114, + 153, + 33, + 214, + 102 + ], + "nonce": [ + 199, + 91, + 131, + 19, + 78, + 123, + 145, + 136, + 229, + 128, + 15, + 254 + ], + "aad": [ + 94, + 244, + 108, + 158, + 181, + 134, + 92, + 171, + 44, + 138, + 53, + 249, + 196, + 196, + 52, + 97, + 74, + 108, + 159, + 27, + 92, + 71, + 151, + 57, + 247, + 67, + 77, + 51, + 38, + 207, + 241, + 231, + 11, + 13, + 40, + 119, + 192, + 132, + 167, + 28, + 122, + 157, + 51, + 210, + 88, + 211, + 4, + 187 + ], + "plaintext": [ + 249, + 162, + 58, + 187, + 208, + 242, + 179, + 103, + 206, + 22, + 194, + 160, + 97, + 60, + 210, + 147, + 172, + 126, + 102, + 203, + 224, + 32, + 234, + 235, + 93, + 235, + 9, + 213, + 3, + 31, + 217, + 146 + ], + "ciphertext": [ + 86, + 228, + 239, + 230, + 192, + 148, + 65, + 83, + 182, + 94, + 212, + 144, + 152, + 69, + 33, + 152, + 66, + 185, + 184, + 143, + 84, + 216, + 216, + 57, + 64, + 81, + 19, + 42, + 251, + 149, + 211, + 145 + ], + "tag": [ + 37, + 94, + 44, + 140, + 67, + 248, + 151, + 156, + 68, + 12, + 53, + 129, + 191, + 246, + 207, + 101 + ] + }, + { + "key": [ + 152, + 49, + 197, + 193, + 46, + 83, + 232, + 169, + 97, + 100, + 46, + 147, + 221, + 178, + 225, + 58, + 56, + 80, + 106, + 205, + 12, + 244, + 34, + 230, + 173, + 159, + 186, + 234, + 188, + 231, + 179, + 242 + ], + "nonce": [ + 191, + 242, + 157, + 227, + 214, + 134, + 158, + 95, + 167, + 91, + 150, + 249 + ], + "aad": [ + 103, + 235, + 238, + 203, + 116, + 204, + 129, + 253, + 254, + 232, + 6, + 95, + 139, + 28, + 31, + 80, + 18, + 191, + 120, + 137, + 83, + 190, + 201, + 82, + 94, + 137, + 102, + 17, + 184, + 39, + 8, + 74, + 142, + 107, + 170, + 12, + 228, + 14, + 231, + 11, + 198, + 153, + 177, + 82, + 188, + 110, + 217, + 3 + ], + "plaintext": [ + 177, + 237, + 190, + 213, + 142, + 211, + 78, + 153, + 247, + 24, + 219, + 6, + 8, + 229, + 77, + 211, + 24, + 131, + 186, + 236, + 28, + 138, + 7, + 153, + 196, + 255, + 138, + 93, + 173, + 70, + 141, + 228 + ], + "ciphertext": [ + 19, + 132, + 93, + 183, + 227, + 59, + 171, + 31, + 87, + 102, + 167, + 250, + 223, + 185, + 66, + 116, + 142, + 119, + 151, + 83, + 217, + 127, + 20, + 62, + 100, + 92, + 207, + 203, + 215, + 194, + 59, + 35 + ], + "tag": [ + 16, + 219, + 232, + 163, + 225, + 144, + 28, + 139, + 136, + 176, + 171, + 20, + 65, + 102, + 77, + 50 + ] + }, + { + "key": [ + 160, + 44, + 45, + 74, + 67, + 240, + 247, + 241, + 219, + 87, + 192, + 127, + 19, + 240, + 127, + 88, + 142, + 223, + 224, + 105, + 169, + 216, + 60, + 155, + 118, + 233, + 81, + 25, + 70, + 196, + 252, + 72 + ], + "nonce": [ + 132, + 103, + 116, + 56, + 89, + 45, + 202, + 246, + 131, + 208, + 138, + 103 + ], + "aad": [ + 213, + 222, + 160, + 205, + 96, + 128, + 175, + 73, + 161, + 198, + 180, + 214, + 154, + 206, + 103, + 74, + 98, + 47, + 132, + 249, + 241, + 144, + 178, + 219, + 138, + 34, + 224, + 132, + 166, + 101, + 0, + 181, + 47, + 242, + 10, + 141, + 4, + 246, + 42, + 122, + 234, + 237, + 182, + 126, + 34, + 88, + 89, + 140 + ], + "plaintext": [ + 173, + 90, + 136, + 77, + 173, + 32, + 255, + 168, + 135, + 148, + 196, + 252, + 163, + 159, + 44, + 160, + 28, + 111, + 103, + 101, + 122, + 179, + 142, + 92, + 248, + 106, + 197, + 89, + 115, + 24, + 239, + 7 + ], + "ciphertext": [ + 131, + 218, + 22, + 174, + 7, + 238, + 14, + 136, + 84, + 132, + 193, + 51, + 10, + 98, + 85, + 166, + 231, + 172, + 34, + 145, + 92, + 99, + 203, + 239, + 170, + 188, + 111, + 159, + 5, + 157, + 214, + 157 + ], + "tag": [ + 66, + 196, + 162, + 112, + 112, + 84, + 147, + 216, + 90, + 215, + 187, + 207, + 218, + 134, + 223, + 251 + ] + }, + { + "key": [ + 254, + 186, + 65, + 43, + 100, + 27, + 199, + 98, + 191, + 167, + 158, + 241, + 124, + 62, + 161, + 110, + 86, + 48, + 96, + 84, + 112, + 219, + 9, + 110, + 54, + 255, + 211, + 56, + 19, + 100, + 26, + 206 + ], + "nonce": [ + 227, + 99, + 63, + 33, + 231, + 198, + 58, + 69, + 157, + 93, + 22, + 112 + ], + "aad": [ + 183, + 238, + 2, + 51, + 134, + 59, + 14, + 24, + 91, + 47, + 70, + 24, + 30, + 181, + 252, + 7, + 24, + 131, + 46, + 30, + 118, + 231, + 212, + 17, + 90, + 76, + 31, + 126, + 153, + 140, + 65, + 49, + 156, + 206, + 244, + 79, + 93, + 184, + 158, + 140, + 95, + 7, + 123, + 213, + 83, + 215, + 191, + 66 + ], + "plaintext": [ + 147, + 38, + 87, + 43, + 211, + 53, + 81, + 50, + 44, + 164, + 47, + 207, + 183, + 206, + 248, + 190, + 65, + 215, + 135, + 37, + 243, + 146, + 195, + 73, + 7, + 236, + 209, + 254, + 85, + 114, + 191, + 241 + ], + "ciphertext": [ + 80, + 25, + 234, + 152, + 204, + 157, + 201, + 54, + 132, + 50, + 198, + 213, + 143, + 158, + 20, + 79, + 85, + 68, + 110, + 118, + 60, + 10, + 139, + 77, + 138, + 108, + 226, + 111, + 61, + 217, + 82, + 96 + ], + "tag": [ + 16, + 16, + 190, + 185, + 205, + 110, + 155, + 97, + 18, + 128, + 165, + 57, + 95, + 8, + 188, + 169 + ] + }, + { + "key": [ + 33, + 189, + 86, + 145, + 247, + 175, + 28, + 231, + 101, + 240, + 153, + 227, + 197, + 192, + 151, + 134, + 147, + 105, + 130, + 131, + 78, + 253, + 129, + 221, + 85, + 39, + 199, + 195, + 34, + 249, + 14, + 131 + ], + "nonce": [ + 54, + 165, + 158, + 82, + 61, + 240, + 75, + 199, + 254, + 183, + 73, + 68 + ], + "aad": [ + 72, + 174, + 245, + 135, + 47, + 103, + 245, + 36, + 181, + 69, + 152, + 120, + 28, + 59, + 40, + 249, + 203, + 207, + 53, + 48, + 102, + 195, + 103, + 3, + 112, + 252, + 164, + 78, + 19, + 39, + 97, + 32, + 49, + 0, + 181, + 230, + 199, + 53, + 42, + 147, + 15, + 126, + 156, + 191, + 40, + 168, + 225, + 206 + ], + "plaintext": [ + 119, + 229, + 57, + 223, + 218, + 180, + 207, + 185, + 48, + 154, + 117, + 194, + 238, + 159, + 158, + 154, + 161, + 180, + 101, + 21, + 104, + 176, + 83, + 144, + 215, + 61, + 161, + 159, + 18, + 204, + 190, + 120 + ], + "ciphertext": [ + 194, + 20, + 131, + 115, + 31, + 127, + 225, + 184, + 161, + 125, + 110, + 19, + 62, + 218, + 22, + 219, + 125, + 115, + 221, + 215, + 227, + 75, + 71, + 238, + 194, + 249, + 155, + 59, + 188, + 150, + 105, + 170 + ], + "tag": [ + 21, + 249, + 38, + 91, + 197, + 35, + 41, + 140, + 239, + 178, + 3, + 55, + 248, + 120, + 178, + 131 + ] + }, + { + "key": [ + 38, + 191, + 37, + 91, + 238, + 96, + 239, + 15, + 101, + 55, + 105, + 231, + 3, + 77, + 185, + 91, + 140, + 121, + 23, + 82, + 117, + 78, + 87, + 92, + 118, + 16, + 89, + 233, + 238, + 141, + 207, + 120 + ], + "nonce": [ + 206, + 205, + 151, + 171, + 7, + 206, + 87, + 193, + 97, + 39, + 68, + 245 + ], + "aad": [ + 175, + 235, + 190, + 159, + 38, + 15, + 140, + 17, + 142, + 82, + 184, + 77, + 136, + 128, + 163, + 70, + 34, + 103, + 95, + 174, + 243, + 52, + 205, + 180, + 27, + 233, + 56, + 91, + 125, + 5, + 155, + 121, + 192, + 248, + 164, + 50, + 210, + 95, + 139, + 113, + 231, + 129, + 177, + 119, + 252, + 228, + 212, + 197, + 122, + 197, + 115, + 69, + 67, + 232, + 93, + 117, + 19, + 249, + 99, + 130, + 255, + 75, + 45, + 75, + 149, + 178, + 241, + 253, + 186, + 249, + 231, + 139, + 189, + 29, + 177, + 58, + 125, + 210, + 110, + 138, + 74, + 200, + 58, + 62, + 138, + 180, + 45, + 29, + 84, + 95 + ], + "plaintext": [ + 150, + 152, + 57, + 23, + 160, + 54, + 101, + 7, + 99, + 172, + 162, + 180, + 233, + 39, + 217, + 95, + 252, + 116, + 51, + 149, + 25, + 237, + 64, + 196, + 51, + 109, + 186, + 145, + 237, + 251, + 249, + 173 + ], + "ciphertext": [ + 227, + 75, + 21, + 64, + 167, + 105, + 247, + 145, + 51, + 49, + 214, + 103, + 150, + 224, + 11, + 220, + 62, + 224, + 242, + 88, + 207, + 36, + 78, + 183, + 102, + 51, + 117, + 204, + 90, + 214, + 198, + 88 + ], + "tag": [ + 56, + 65, + 240, + 43, + 235, + 122, + 127, + 202, + 126, + 87, + 137, + 34, + 208, + 162, + 248, + 12 + ] + }, + { + "key": [ + 116, + 206, + 49, + 33, + 193, + 139, + 191, + 244, + 117, + 106, + 209, + 13, + 15, + 41, + 59, + 177, + 234, + 63, + 147, + 73, + 13, + 170, + 208, + 36, + 156, + 211, + 176, + 94, + 34, + 60, + 151, + 71 + ], + "nonce": [ + 129, + 16, + 122, + 251, + 76, + 38, + 79, + 101, + 174, + 0, + 2, + 177 + ], + "aad": [ + 240, + 8, + 71, + 248, + 72, + 215, + 88, + 73, + 74, + 253, + 144, + 182, + 196, + 147, + 117, + 224, + 231, + 110, + 38, + 220, + 186, + 40, + 78, + 154, + 96, + 142, + 174, + 51, + 184, + 122, + 210, + 222, + 172, + 40, + 204, + 244, + 13, + 45, + 177, + 84, + 187, + 225, + 13, + 192, + 253, + 105, + 176, + 156, + 155, + 137, + 32, + 240, + 247, + 78, + 166, + 45, + 214, + 141, + 242, + 117, + 7, + 78, + 40, + 142, + 118, + 162, + 144, + 51, + 107, + 59, + 246, + 180, + 133, + 192, + 21, + 149, + 37, + 195, + 98, + 9, + 36, + 8, + 245, + 17, + 103, + 200, + 229, + 158, + 33, + 143 + ], + "plaintext": [ + 122, + 19, + 51, + 133, + 234, + 213, + 147, + 195, + 144, + 120, + 6, + 190, + 193, + 34, + 64, + 148, + 63, + 0, + 168, + 195, + 193, + 176, + 172, + 115, + 184, + 184, + 26, + 242, + 211, + 25, + 44, + 111 + ], + "ciphertext": [ + 100, + 189, + 23, + 243, + 232, + 247, + 26, + 72, + 68, + 185, + 112, + 212, + 235, + 193, + 25, + 150, + 24, + 18, + 239, + 185, + 1, + 91, + 129, + 142, + 141, + 136, + 185, + 6, + 213, + 239, + 189, + 118 + ], + "tag": [ + 70, + 208, + 228, + 42, + 160, + 70, + 35, + 126, + 254, + 225, + 126, + 171, + 109, + 156, + 251, + 117 + ] + }, + { + "key": [ + 76, + 102, + 154, + 25, + 105, + 201, + 125, + 86, + 218, + 48, + 164, + 98, + 54, + 193, + 84, + 7, + 224, + 106, + 173, + 166, + 134, + 32, + 94, + 237, + 59, + 215, + 121, + 107, + 2, + 201, + 122, + 75 + ], + "nonce": [ + 10, + 7, + 117, + 141, + 90, + 212, + 71, + 102, + 224, + 81, + 218, + 108 + ], + "aad": [ + 11, + 130, + 119, + 17, + 76, + 191, + 126, + 225, + 108, + 155, + 189, + 161, + 171, + 64, + 65, + 154, + 2, + 228, + 105, + 235, + 178, + 149, + 136, + 63, + 10, + 131, + 60, + 60, + 183, + 85, + 222, + 212, + 74, + 60, + 65, + 0, + 52, + 162, + 1, + 247, + 217, + 27, + 67, + 81, + 159, + 186, + 187, + 85, + 185, + 116, + 131, + 75, + 229, + 213, + 175, + 199, + 174, + 167, + 200, + 75, + 68, + 161, + 78, + 142, + 22, + 221, + 104, + 163, + 232, + 204, + 121, + 173, + 43, + 247, + 109, + 12, + 235, + 51, + 213, + 141, + 219, + 99, + 120, + 180, + 86, + 129, + 206, + 170, + 15, + 47 + ], + "plaintext": [ + 205, + 89, + 187, + 48, + 123, + 231, + 111, + 17, + 48, + 79, + 105, + 172, + 139, + 21, + 30, + 22, + 40, + 172, + 97, + 222, + 200, + 16, + 134, + 231, + 242, + 79, + 213, + 189, + 131, + 223, + 136, + 86 + ], + "ciphertext": [ + 188, + 98, + 206, + 11, + 35, + 207, + 74, + 168, + 225, + 107, + 68, + 80, + 200, + 171, + 140, + 98, + 154, + 83, + 148, + 159, + 1, + 230, + 139, + 135, + 94, + 204, + 92, + 69, + 255, + 109, + 58, + 176 + ], + "tag": [ + 95, + 254, + 218, + 114, + 137, + 20, + 3, + 16, + 6, + 242, + 113, + 195, + 217, + 152, + 111, + 45 + ] + }, + { + "key": [ + 162, + 50, + 150, + 99, + 41, + 19, + 5, + 30, + 67, + 129, + 20, + 222, + 183, + 130, + 251, + 149, + 91, + 117, + 172, + 195, + 94, + 134, + 231, + 233, + 253, + 175, + 78, + 144, + 37, + 184, + 127, + 18 + ], + "nonce": [ + 173, + 80, + 219, + 64, + 248, + 15, + 21, + 33, + 78, + 67, + 255, + 215 + ], + "aad": [ + 166, + 249, + 111, + 90, + 137, + 191, + 216, + 200, + 243, + 76, + 208, + 112, + 69, + 39, + 13, + 128, + 229, + 142, + 166, + 47, + 31, + 11, + 16, + 242, + 80, + 106, + 149, + 79, + 39, + 42, + 240, + 188, + 113, + 223, + 150, + 173, + 63, + 168, + 238, + 213, + 44, + 69, + 224, + 184, + 104, + 9, + 29, + 196, + 247, + 93, + 158, + 14, + 175, + 21, + 160, + 168, + 88, + 167, + 27, + 247, + 3, + 108, + 86, + 7, + 17, + 12, + 191, + 228, + 122, + 217, + 182, + 208, + 46, + 148, + 47, + 207, + 174, + 136, + 212, + 199, + 146, + 161, + 248, + 36, + 230, + 14, + 60, + 249, + 138, + 55 + ], + "plaintext": [ + 183, + 17, + 22, + 204, + 39, + 181, + 165, + 132, + 77, + 155, + 81, + 164, + 167, + 32, + 203, + 63, + 6, + 213, + 93, + 106, + 174, + 174, + 175, + 146, + 18, + 54, + 66, + 77, + 184, + 97, + 114, + 4 + ], + "ciphertext": [ + 142, + 158, + 75, + 10, + 201, + 58, + 184, + 231, + 54, + 136, + 214, + 180, + 114, + 61, + 140, + 94, + 243, + 153, + 234, + 215, + 34, + 70, + 199, + 170, + 122, + 7, + 131, + 168, + 191, + 226, + 153, + 54 + ], + "tag": [ + 183, + 222, + 169, + 30, + 75, + 53, + 124, + 232, + 5, + 237, + 238, + 163, + 249, + 19, + 146, + 210 + ] + }, + { + "key": [ + 64, + 54, + 160, + 123, + 221, + 78, + 16, + 235, + 84, + 95, + 61, + 145, + 36, + 201, + 247, + 102, + 210, + 208, + 200, + 197, + 159, + 192, + 213, + 131, + 90, + 197, + 93, + 207, + 174, + 191, + 195, + 161 + ], + "nonce": [ + 129, + 88, + 40, + 251, + 185, + 100, + 73, + 124, + 218, + 220, + 202, + 173 + ], + "aad": [ + 11, + 192, + 227, + 147, + 19, + 136, + 188, + 176, + 145, + 70, + 59, + 174, + 41, + 137, + 169, + 59, + 222, + 16, + 59, + 193, + 79, + 197, + 211, + 159, + 148, + 72, + 202, + 144, + 54, + 126, + 134, + 51, + 107, + 24, + 143, + 115, + 33, + 139, + 43, + 10, + 183, + 42, + 154, + 86, + 74, + 213, + 255, + 50, + 84, + 76, + 90, + 254, + 172, + 236, + 173, + 250, + 85, + 210, + 251, + 102, + 146, + 90, + 136, + 41, + 157, + 191, + 88, + 244, + 37, + 207, + 73, + 227, + 31, + 66, + 172, + 78, + 218, + 206, + 116, + 63, + 223, + 150, + 128, + 210, + 14, + 200, + 69, + 175, + 194, + 120 + ], + "plaintext": [ + 113, + 127, + 34, + 250, + 255, + 128, + 102, + 24, + 46, + 70, + 211, + 45, + 186, + 199, + 131, + 30, + 194, + 66, + 114, + 135, + 28, + 69, + 199, + 193, + 44, + 167, + 121, + 248, + 104, + 231, + 115, + 154 + ], + "ciphertext": [ + 232, + 195, + 176, + 52, + 41, + 100, + 199, + 167, + 31, + 8, + 77, + 68, + 186, + 47, + 147, + 116, + 43, + 204, + 217, + 130, + 27, + 48, + 8, + 125, + 17, + 181, + 59, + 190, + 139, + 8, + 88, + 8 + ], + "tag": [ + 134, + 221, + 217, + 196, + 105, + 132, + 156, + 182, + 177, + 0, + 195, + 57, + 202, + 98, + 113, + 125 + ] + }, + { + "key": [ + 113, + 75, + 195, + 186, + 56, + 57, + 172, + 103, + 7, + 134, + 58, + 64, + 170, + 61, + 181, + 162, + 238, + 188, + 179, + 141, + 198, + 236, + 109, + 34, + 176, + 131, + 206, + 242, + 68, + 251, + 9, + 247 + ], + "nonce": [ + 44, + 254, + 28, + 81, + 216, + 148, + 229, + 239, + 47, + 90, + 44, + 60 + ], + "aad": [ + 132, + 227, + 212, + 106, + 242, + 236, + 183, + 23, + 163, + 144, + 36, + 214, + 43, + 188, + 36, + 209, + 25, + 245, + 175, + 245, + 117, + 105, + 223, + 239, + 148, + 231, + 219, + 113, + 173, + 90, + 255, + 134, + 74, + 186, + 205, + 197, + 248, + 85, + 78, + 24, + 237, + 81, + 41, + 207, + 179, + 54, + 109, + 52, + 156, + 82, + 179, + 209, + 161, + 17, + 184, + 103, + 232, + 119, + 33, + 64, + 116, + 158, + 127, + 51, + 226, + 230, + 66, + 89, + 150, + 132, + 134, + 227, + 47, + 4, + 125, + 33, + 18, + 13, + 167, + 60, + 119, + 117, + 124, + 69, + 149, + 204, + 172, + 27, + 87, + 19 + ], + "plaintext": [ + 12, + 196, + 161, + 139, + 191, + 234, + 135, + 222, + 10, + 195, + 68, + 108, + 119, + 123, + 227, + 140, + 168, + 67, + 209, + 111, + 147, + 190, + 44, + 18, + 199, + 144, + 253, + 164, + 222, + 148, + 201, + 191 + ], + "ciphertext": [ + 8, + 87, + 200, + 251, + 147, + 65, + 47, + 222, + 105, + 186, + 210, + 135, + 180, + 61, + 238, + 163, + 101, + 6, + 215, + 238, + 6, + 29, + 104, + 68, + 208, + 10, + 126, + 119, + 65, + 143, + 112, + 47 + ], + "tag": [ + 36, + 169, + 229, + 41, + 9, + 87, + 7, + 72, + 7, + 213, + 90, + 215, + 5, + 173, + 170, + 137 + ] + }, + { + "key": [ + 47, + 147, + 181, + 163, + 123, + 225, + 164, + 56, + 83, + 191, + 31, + 213, + 120, + 6, + 29, + 7, + 68, + 230, + 189, + 137, + 51, + 124, + 222, + 32, + 23, + 125, + 30, + 149, + 162, + 182, + 66, + 196 + ], + "nonce": [ + 82, + 182, + 217, + 21, + 87, + 174, + 21, + 170, + 121, + 44, + 228, + 183 + ], + "aad": [ + 153, + 43, + 169, + 239, + 162, + 135, + 165, + 195, + 229, + 23, + 123, + 212, + 147, + 26, + 244, + 152, + 152, + 42, + 23, + 40, + 181, + 107, + 61, + 124, + 75, + 40, + 71, + 105, + 5, + 226, + 159, + 131, + 50, + 108, + 79, + 50, + 35, + 162, + 136, + 68, + 252, + 155, + 157, + 132, + 212, + 246, + 205, + 133, + 144, + 116, + 175, + 246, + 71, + 163, + 93, + 222, + 40, + 225, + 238, + 136, + 159, + 170, + 179, + 187, + 156, + 9, + 164, + 195, + 251, + 242, + 161, + 100, + 96, + 212, + 138, + 64, + 220, + 83, + 55, + 141, + 70, + 115, + 244, + 50, + 94, + 106, + 163, + 153, + 42, + 113 + ], + "plaintext": [ + 15, + 202, + 163, + 22, + 161, + 53, + 216, + 16, + 82, + 80, + 157, + 216, + 95, + 104, + 138, + 237, + 46, + 95, + 212, + 38, + 30, + 23, + 79, + 67, + 92, + 241, + 196, + 17, + 90, + 166, + 243, + 84 + ], + "ciphertext": [ + 249, + 151, + 116, + 206, + 243, + 193, + 90, + 243, + 60, + 218, + 60, + 180, + 73, + 205, + 51, + 95, + 254, + 79, + 39, + 67, + 94, + 223, + 131, + 175, + 244, + 164, + 244, + 194, + 210, + 223, + 102, + 71 + ], + "tag": [ + 197, + 224, + 155, + 131, + 177, + 194, + 204, + 129, + 228, + 138, + 31, + 124, + 98, + 183, + 187, + 53 + ] + }, + { + "key": [ + 83, + 28, + 168, + 69, + 175, + 123, + 247, + 49, + 196, + 156, + 49, + 54, + 64, + 115, + 34, + 177, + 192, + 246, + 179, + 43, + 142, + 174, + 191, + 3, + 116, + 75, + 46, + 220, + 18, + 2, + 208, + 150 + ], + "nonce": [ + 186, + 241, + 59, + 133, + 32, + 43, + 191, + 200, + 153, + 252, + 115, + 247 + ], + "aad": [ + 226, + 186, + 156, + 245, + 72, + 180, + 246, + 251, + 32, + 111, + 34, + 66, + 80, + 216, + 90, + 243, + 39, + 253, + 232, + 208, + 137, + 22, + 104, + 106, + 231, + 112, + 32, + 61, + 194, + 156, + 105, + 79, + 137, + 2, + 176, + 34, + 34, + 253, + 40, + 127, + 40, + 206, + 96, + 145, + 0, + 99, + 104, + 195, + 148, + 155, + 234, + 41, + 55, + 255, + 11, + 222, + 219, + 125, + 187, + 208, + 19, + 204, + 240, + 161, + 94, + 224, + 175, + 140, + 86, + 254, + 33, + 27, + 124, + 49, + 30, + 24, + 47, + 39, + 112, + 127, + 89, + 224, + 148, + 146, + 179, + 96, + 78, + 128, + 198, + 197 + ], + "plaintext": [ + 212, + 233, + 120, + 63, + 83, + 124, + 115, + 130, + 0, + 231, + 186, + 117, + 38, + 96, + 95, + 53, + 154, + 152, + 201, + 241, + 12, + 175, + 170, + 47, + 67, + 60, + 64, + 243, + 229, + 8, + 26, + 54 + ], + "ciphertext": [ + 100, + 47, + 84, + 73, + 41, + 32, + 33, + 40, + 167, + 131, + 185, + 133, + 211, + 111, + 96, + 150, + 76, + 125, + 120, + 225, + 212, + 31, + 93, + 27, + 254, + 39, + 222, + 58, + 224, + 24, + 13, + 243 + ], + "tag": [ + 227, + 51, + 82, + 140, + 89, + 238, + 25, + 9, + 117, + 14, + 215, + 47, + 209, + 48, + 158, + 225 + ] + }, + { + "key": [ + 58, + 221, + 23, + 86, + 141, + 170, + 157, + 68, + 26, + 167, + 168, + 155, + 248, + 143, + 164, + 230, + 153, + 138, + 146, + 29, + 87, + 228, + 148, + 162, + 84, + 8, + 4, + 69, + 188, + 155, + 111, + 53 + ], + "nonce": [ + 178, + 144, + 244, + 165, + 36, + 150, + 56, + 2, + 24, + 195, + 220, + 245 + ], + "aad": [ + 11, + 201, + 204, + 19, + 235, + 40, + 144, + 170, + 96, + 81, + 92, + 34, + 151, + 169, + 159, + 9, + 47, + 110, + 81, + 98, + 54, + 192, + 222, + 201, + 249, + 134, + 234, + 152, + 184, + 161, + 128, + 104, + 15, + 44, + 108, + 32, + 189, + 67, + 84, + 195, + 52, + 51, + 164, + 198, + 246, + 162, + 94, + 99, + 47, + 144, + 235, + 239, + 58, + 56, + 60, + 53, + 146, + 38, + 139, + 72, + 62, + 235, + 245, + 245, + 219, + 0, + 105, + 41, + 231, + 152, + 126, + 219, + 202, + 196, + 117, + 93, + 58, + 253, + 28, + 223, + 155, + 2, + 149, + 78, + 189, + 79, + 239, + 83, + 213, + 246 + ], + "plaintext": [ + 44, + 105, + 8, + 203, + 52, + 33, + 95, + 137, + 163, + 243, + 163, + 200, + 146, + 232, + 136, + 127, + 46, + 250, + 73, + 106, + 21, + 171, + 145, + 63, + 199, + 211, + 76, + 199, + 12, + 13, + 255, + 121 + ], + "ciphertext": [ + 44, + 243, + 190, + 174, + 148, + 253, + 94, + 106, + 65, + 38, + 168, + 236, + 138, + 113, + 102, + 176, + 170, + 203, + 139, + 139, + 188, + 228, + 93, + 97, + 6, + 183, + 141, + 52, + 86, + 208, + 81, + 73 + ], + "tag": [ + 206, + 21, + 9, + 177, + 189, + 92, + 71, + 165, + 147, + 112, + 38, + 24, + 176, + 215, + 159, + 108 + ] + }, + { + "key": [ + 28, + 29, + 207, + 212, + 196, + 204, + 75, + 235, + 113, + 214, + 227, + 104, + 247, + 57, + 216, + 230, + 129, + 223, + 228, + 143, + 186, + 227, + 151, + 40, + 56, + 108, + 157, + 252, + 8, + 130, + 87, + 67 + ], + "nonce": [ + 13, + 236, + 235, + 105, + 206, + 13, + 199, + 118, + 163, + 167, + 27, + 76 + ], + "aad": [ + 163, + 175, + 45, + 182, + 114, + 41, + 36, + 49, + 250, + 142, + 225, + 250, + 91, + 25, + 117, + 147, + 177, + 62, + 88, + 166, + 140, + 65, + 41, + 64, + 29, + 9, + 66, + 71, + 77, + 95, + 76, + 190, + 98, + 9, + 58, + 170, + 84, + 83, + 246, + 211, + 85, + 210, + 244, + 182, + 220, + 138, + 189, + 229, + 140, + 232, + 99, + 209, + 190, + 95, + 158, + 207, + 57, + 115, + 10, + 73, + 86, + 91, + 59, + 104, + 130, + 160, + 166, + 65, + 192, + 181, + 209, + 86, + 164, + 16, + 115, + 9, + 221, + 21, + 15, + 209, + 241, + 99, + 78, + 164, + 229, + 16, + 11, + 61, + 79, + 136 + ], + "plaintext": [ + 177, + 39, + 0, + 37, + 138, + 206, + 123, + 22, + 228, + 15, + 78, + 134, + 136, + 104, + 146, + 131, + 113, + 104, + 178, + 86, + 161, + 112, + 147, + 122, + 59, + 137, + 6, + 58, + 154, + 13, + 104, + 247 + ], + "ciphertext": [ + 62, + 167, + 241, + 192, + 214, + 19, + 50, + 62, + 9, + 85, + 88, + 221, + 222, + 83, + 36, + 116, + 32, + 250, + 14, + 239, + 23, + 153, + 122, + 30, + 156, + 91, + 169, + 61, + 95, + 36, + 196, + 111 + ], + "tag": [ + 112, + 83, + 74, + 135, + 194, + 88, + 144, + 93, + 53, + 128, + 111, + 68, + 57, + 246, + 144, + 110 + ] + }, + { + "key": [ + 242, + 114, + 65, + 83, + 170, + 201, + 213, + 15, + 53, + 8, + 120, + 211, + 196, + 152, + 188, + 61, + 215, + 130, + 217, + 12, + 206, + 92, + 206, + 74, + 225, + 65, + 38, + 192, + 225, + 251, + 179, + 207 + ], + "nonce": [ + 28, + 7, + 182, + 28, + 83, + 22, + 101, + 155, + 173, + 101, + 204, + 169 + ], + "aad": [ + 230, + 157, + 183, + 252, + 211, + 181, + 144, + 166, + 211, + 32, + 82, + 97, + 32, + 52, + 3, + 109, + 92, + 139, + 255, + 165, + 229, + 233, + 183, + 66, + 255, + 231, + 90, + 159, + 187, + 168, + 157, + 213, + 118, + 222, + 192, + 129, + 84, + 207, + 78, + 109, + 54, + 240, + 253, + 212, + 65, + 155, + 223, + 80, + 173, + 193, + 151, + 74, + 128, + 234, + 49, + 52, + 33, + 201, + 38, + 223, + 250, + 135, + 86, + 91, + 75, + 208, + 193, + 232, + 79, + 47, + 243, + 5, + 175, + 145, + 135, + 127, + 131, + 15, + 20, + 91, + 177, + 61, + 250, + 126, + 250, + 94, + 58, + 166, + 130, + 230 + ], + "plaintext": [ + 6, + 124, + 203, + 208, + 32, + 111, + 31, + 5, + 210, + 135, + 34, + 16, + 220, + 87, + 23, + 160, + 88, + 94, + 129, + 149, + 215, + 42, + 253, + 12, + 119, + 218, + 17, + 185, + 179, + 113, + 14, + 68 + ], + "ciphertext": [ + 154, + 186, + 67, + 62, + 239, + 56, + 52, + 102, + 161, + 41, + 27, + 212, + 134, + 195, + 206, + 94, + 14, + 209, + 38, + 1, + 14, + 10, + 119, + 191, + 3, + 124, + 94, + 174, + 210, + 199, + 36, + 96 + ], + "tag": [ + 243, + 10, + 21, + 94, + 53, + 64, + 11, + 176, + 84, + 8, + 131, + 232, + 224, + 155, + 74, + 253 + ] + }, + { + "key": [ + 162, + 84, + 78, + 178, + 4, + 124, + 151, + 207, + 202, + 240, + 236, + 20, + 39, + 197, + 223, + 57, + 84, + 114, + 40, + 82, + 51, + 169, + 63, + 252, + 205, + 168, + 254, + 230, + 96, + 172, + 237, + 86 + ], + "nonce": [ + 167, + 81, + 190, + 163, + 199, + 105, + 187, + 93, + 178, + 90, + 177, + 9 + ], + "aad": [ + 235, + 158, + 9, + 136, + 77, + 225, + 69, + 77, + 106, + 235, + 13, + 108, + 130, + 55, + 95, + 36, + 40, + 153, + 32, + 49, + 234, + 108, + 171, + 246, + 162, + 154, + 166, + 164, + 222, + 73, + 163, + 83, + 228, + 255, + 174, + 4, + 61, + 173, + 24, + 174, + 101, + 27, + 32, + 183, + 188, + 161, + 63, + 92, + 50, + 124, + 169, + 241, + 50, + 1, + 75, + 250, + 134, + 231, + 22, + 212, + 114, + 78, + 5, + 161, + 239, + 103, + 85, + 33, + 166, + 96, + 122, + 83, + 103, + 86, + 230, + 168, + 193, + 107, + 184, + 133, + 182, + 72, + 21, + 241, + 235, + 94, + 194, + 130, + 206, + 142 + ], + "plaintext": [ + 185, + 81, + 76, + 192, + 26, + 53, + 118, + 5, + 145, + 143, + 156, + 193, + 145, + 35, + 220, + 200, + 219, + 50, + 140, + 96, + 92, + 160, + 235, + 157, + 105, + 216, + 113, + 175, + 238, + 161, + 220, + 251 + ], + "ciphertext": [ + 203, + 68, + 43, + 23, + 8, + 143, + 106, + 197, + 242, + 76, + 122, + 4, + 240, + 5, + 5, + 89, + 56, + 111, + 58, + 87, + 19, + 27, + 146, + 165, + 65, + 66, + 199, + 165, + 86, + 253, + 185, + 53 + ], + "tag": [ + 95, + 128, + 197, + 192, + 205, + 240, + 199, + 137, + 11, + 253, + 31, + 189, + 88, + 195, + 48, + 129 + ] + }, + { + "key": [ + 206, + 176, + 87, + 120, + 46, + 251, + 30, + 133, + 216, + 5, + 68, + 138, + 249, + 70, + 169, + 180, + 212, + 18, + 139, + 240, + 154, + 18, + 71, + 60, + 206, + 30, + 142, + 248, + 191, + 210, + 134, + 157 + ], + "nonce": [ + 64, + 111, + 151, + 48, + 233, + 177, + 228, + 33, + 228, + 40, + 67, + 155 + ], + "aad": [ + 7, + 114, + 174, + 0, + 225, + 202, + 5, + 208, + 150, + 207, + 83, + 63, + 211, + 222, + 40, + 24, + 172, + 120, + 62, + 223, + 202, + 14, + 238, + 118, + 134, + 166, + 41, + 15, + 51, + 87, + 72, + 30, + 136, + 63, + 178, + 248, + 149, + 185, + 164, + 244, + 0, + 76, + 86, + 184, + 161, + 38, + 82, + 66, + 207, + 223, + 31, + 180, + 175, + 126, + 220, + 65, + 237, + 120, + 197, + 244, + 255, + 233, + 196, + 8, + 13, + 74, + 23, + 49, + 143, + 156, + 86, + 236, + 219, + 58, + 6, + 243, + 199, + 72, + 83, + 83, + 135, + 213, + 106, + 9, + 105, + 67, + 167, + 109, + 70, + 246 + ], + "plaintext": [ + 8, + 21, + 114, + 61, + 83, + 103, + 177, + 50, + 140, + 172, + 99, + 47, + 162, + 110, + 35, + 242, + 184, + 20, + 161, + 213, + 154, + 41, + 113, + 217, + 77, + 2, + 235, + 215, + 236, + 245, + 193, + 74 + ], + "ciphertext": [ + 157, + 130, + 53, + 93, + 142, + 70, + 8, + 150, + 32, + 27, + 225, + 95, + 217, + 95, + 237, + 72, + 168, + 82, + 70, + 102, + 217, + 135, + 171, + 7, + 133, + 80, + 136, + 48, + 52, + 208, + 37, + 60 + ], + "tag": [ + 160, + 190, + 232, + 172, + 14, + 99, + 109, + 100, + 211, + 177, + 235, + 51, + 253, + 111, + 33, + 212 + ] + }, + { + "key": [ + 125, + 189, + 189, + 254, + 54, + 212, + 147, + 105, + 64, + 173, + 109, + 111, + 118, + 198, + 124, + 40, + 81, + 160, + 71, + 127, + 10, + 167, + 214, + 121, + 123, + 253, + 242, + 183, + 135, + 142, + 247, + 224 + ], + "nonce": [ + 188, + 103, + 43, + 34, + 75, + 75, + 107, + 145, + 252, + 63, + 214, + 151 + ], + "aad": [ + 250, + 172, + 184, + 78, + 199, + 207, + 173, + 215, + 49, + 222, + 47, + 124, + 8, + 146, + 215, + 227, + 140, + 191, + 183, + 130, + 180, + 132, + 18, + 51, + 26, + 240, + 179, + 234, + 182, + 2, + 167, + 34, + 202, + 209, + 6, + 157, + 234, + 0, + 82, + 190, + 181, + 202, + 112, + 226, + 238, + 71, + 108, + 52, + 12, + 97, + 147, + 188, + 198, + 15, + 147, + 154, + 171, + 228, + 70, + 191, + 60, + 233, + 88, + 254, + 17, + 162, + 255, + 201, + 2, + 65, + 240, + 167, + 228, + 226, + 116, + 240, + 193, + 68, + 29, + 239, + 121, + 88, + 147, + 137, + 91, + 216, + 72, + 191, + 15, + 14 + ], + "plaintext": [ + 223, + 234, + 70, + 61, + 53, + 240, + 250, + 32, + 72, + 123, + 96, + 109, + 108, + 207, + 212, + 34, + 165, + 183, + 7, + 241, + 101, + 39, + 180, + 34, + 191, + 29, + 104, + 167, + 125, + 182, + 126, + 156 + ], + "ciphertext": [ + 13, + 220, + 34, + 129, + 177, + 252, + 185, + 4, + 134, + 74, + 67, + 101, + 123, + 199, + 35, + 87, + 207, + 115, + 252, + 31, + 22, + 82, + 12, + 170, + 215, + 205, + 221, + 225, + 15, + 132, + 107, + 217 + ], + "tag": [ + 157, + 150, + 105, + 148, + 80, + 170, + 151, + 7, + 105, + 94, + 93, + 229, + 101, + 151, + 16, + 27 + ] + }, + { + "key": [ + 24, + 114, + 20, + 223, + 110, + 45, + 128, + 238, + 142, + 154, + 174, + 31, + 197, + 105, + 172, + 212, + 21, + 137, + 233, + 82, + 221, + 203, + 232, + 218, + 1, + 133, + 80, + 209, + 3, + 118, + 113, + 34 + ], + "nonce": [ + 86, + 219, + 51, + 68, + 34, + 182, + 197, + 233, + 52, + 96, + 208, + 19 + ], + "aad": [ + 203, + 237, + 183, + 204, + 251, + 245, + 109, + 253, + 114, + 229, + 48, + 191, + 225, + 107, + 79, + 90, + 172, + 72, + 169, + 2, + 4, + 188, + 183, + 168, + 202, + 225, + 4, + 96, + 16, + 136, + 44, + 252, + 139, + 82, + 110, + 117, + 98, + 167, + 136, + 9, + 20, + 230, + 27, + 96, + 203, + 214, + 5, + 22, + 82, + 66, + 115, + 125, + 133, + 238, + 237, + 88, + 60, + 152, + 202, + 179, + 68, + 56, + 116, + 229, + 152, + 158, + 201, + 205, + 224, + 1, + 173, + 247, + 222, + 156, + 153, + 103, + 222, + 81, + 120, + 247, + 91, + 132, + 18, + 176, + 196, + 214, + 254, + 197, + 175, + 114 + ], + "plaintext": [ + 83, + 53, + 82, + 131, + 24, + 103, + 25, + 169, + 20, + 108, + 115, + 5, + 227, + 209, + 149, + 154, + 17, + 204, + 241, + 151, + 87, + 11, + 133, + 90, + 67, + 203, + 199, + 86, + 58, + 5, + 60, + 115 + ], + "ciphertext": [ + 194, + 38, + 37, + 133, + 150, + 107, + 201, + 194, + 61, + 199, + 204, + 16, + 89, + 208, + 96, + 33, + 30, + 134, + 243, + 179, + 22, + 29, + 56, + 177, + 83, + 99, + 95, + 190, + 164, + 162, + 140, + 5 + ], + "tag": [ + 169, + 66, + 151, + 197, + 132, + 223, + 205, + 16, + 238, + 93, + 241, + 154, + 46, + 229, + 195, + 210 + ] + }, + { + "key": [ + 31, + 222, + 211, + 45, + 89, + 153, + 222, + 74, + 118, + 224, + 248, + 8, + 33, + 8, + 130, + 58, + 239, + 96, + 65, + 126, + 24, + 150, + 207, + 66, + 24, + 162, + 250, + 144, + 246, + 50, + 236, + 138 + ], + "nonce": [ + 31, + 58, + 250, + 71, + 17, + 233, + 71, + 79, + 50, + 231, + 4, + 98 + ], + "aad": [], + "plaintext": [ + 6, + 178, + 199, + 88, + 83, + 223, + 154, + 235, + 23, + 190, + 253, + 51, + 206, + 168, + 28, + 99, + 11, + 15, + 197, + 54, + 103, + 255, + 69, + 25, + 156, + 98, + 156, + 142, + 21, + 220, + 228, + 30, + 83, + 10, + 167, + 146, + 247, + 150, + 184, + 19, + 142, + 234, + 178, + 232, + 108, + 123, + 123, + 238, + 29, + 64, + 176 + ], + "ciphertext": [ + 145, + 251, + 208, + 97, + 221, + 197, + 167, + 252, + 201, + 81, + 63, + 205, + 253, + 201, + 195, + 167, + 197, + 212, + 214, + 76, + 237, + 246, + 169, + 194, + 74, + 184, + 167, + 124, + 54, + 238, + 251, + 241, + 197, + 220, + 0, + 188, + 80, + 18, + 27, + 150, + 69, + 108, + 140, + 216, + 182, + 255, + 31, + 139, + 62, + 72, + 15 + ], + "tag": [ + 48, + 9, + 109, + 52, + 15, + 61, + 92, + 66, + 216, + 42, + 111, + 71, + 93, + 239, + 35, + 235 + ] + }, + { + "key": [ + 180, + 5, + 172, + 137, + 114, + 79, + 139, + 85, + 91, + 254, + 225, + 234, + 163, + 105, + 205, + 133, + 64, + 3, + 233, + 250, + 228, + 21, + 242, + 140, + 90, + 25, + 157, + 77, + 110, + 252, + 131, + 214 + ], + "nonce": [ + 206, + 199, + 26, + 19, + 177, + 76, + 77, + 155, + 208, + 36, + 239, + 41 + ], + "aad": [], + "plaintext": [ + 171, + 79, + 211, + 91, + 239, + 102, + 173, + 223, + 210, + 133, + 107, + 56, + 129, + 255, + 44, + 116, + 253, + 192, + 156, + 130, + 171, + 227, + 57, + 244, + 151, + 54, + 214, + 155, + 43, + 208, + 167, + 26, + 107, + 79, + 232, + 252, + 83, + 245, + 15, + 139, + 125, + 109, + 109, + 97, + 56, + 171, + 68, + 44, + 127, + 101, + 63 + ], + "ciphertext": [ + 105, + 160, + 121, + 188, + 169, + 166, + 162, + 103, + 7, + 187, + 250, + 127, + 216, + 61, + 93, + 9, + 30, + 220, + 136, + 167, + 247, + 255, + 8, + 189, + 134, + 86, + 216, + 242, + 201, + 33, + 68, + 255, + 35, + 64, + 15, + 203, + 92, + 55, + 11, + 89, + 106, + 214, + 113, + 31, + 56, + 110, + 24, + 242, + 98, + 158, + 118 + ], + "tag": [ + 109, + 43, + 120, + 97, + 163, + 197, + 155, + 165, + 163, + 227, + 161, + 28, + 146, + 187, + 43, + 20 + ] + }, + { + "key": [ + 250, + 212, + 12, + 130, + 38, + 77, + 201, + 184, + 217, + 164, + 44, + 16, + 162, + 52, + 19, + 131, + 68, + 176, + 19, + 58, + 112, + 141, + 136, + 153, + 218, + 147, + 75, + 254, + 226, + 189, + 214, + 184 + ], + "nonce": [ + 13, + 173, + 226, + 201, + 90, + 155, + 133, + 168, + 210, + 188, + 19, + 239 + ], + "aad": [], + "plaintext": [ + 102, + 78, + 169, + 93, + 81, + 27, + 44, + 253, + 185, + 229, + 251, + 135, + 239, + 221, + 65, + 203, + 251, + 136, + 243, + 255, + 71, + 167, + 210, + 184, + 131, + 9, + 103, + 227, + 144, + 113, + 168, + 155, + 148, + 135, + 84, + 255, + 176, + 237, + 52, + 195, + 87, + 237, + 109, + 75, + 75, + 47, + 138, + 118, + 97, + 92, + 3 + ], + "ciphertext": [ + 234, + 148, + 220, + 191, + 82, + 178, + 34, + 38, + 221, + 169, + 29, + 155, + 252, + 150, + 251, + 56, + 39, + 48, + 178, + 19, + 182, + 110, + 48, + 150, + 11, + 13, + 32, + 210, + 65, + 112, + 54, + 203, + 170, + 158, + 53, + 153, + 132, + 238, + 169, + 71, + 35, + 37, + 38, + 225, + 117, + 244, + 151, + 57, + 9, + 94, + 105 + ], + "tag": [ + 92, + 168, + 144, + 93, + 70, + 159, + 255, + 236, + 111, + 186, + 116, + 53, + 235, + 223, + 253, + 175 + ] + }, + { + "key": [ + 170, + 95, + 202, + 104, + 140, + 200, + 50, + 131, + 236, + 243, + 148, + 84, + 103, + 153, + 72, + 244, + 211, + 10, + 168, + 203, + 67, + 219, + 124, + 196, + 218, + 78, + 255, + 22, + 105, + 214, + 197, + 47 + ], + "nonce": [ + 75, + 45, + 123, + 105, + 154, + 82, + 89, + 249, + 181, + 65, + 250, + 73 + ], + "aad": [], + "plaintext": [ + 198, + 145, + 243, + 184, + 243, + 145, + 126, + 251, + 118, + 130, + 81, + 8, + 192, + 227, + 125, + 195, + 62, + 122, + 131, + 66, + 118, + 76, + 230, + 138, + 98, + 162, + 220, + 26, + 92, + 148, + 5, + 148, + 150, + 31, + 205, + 92, + 13, + 240, + 83, + 148, + 165, + 192, + 255, + 246, + 108, + 37, + 76, + 107, + 38, + 165, + 73 + ], + "ciphertext": [ + 44, + 211, + 128, + 235, + 214, + 178, + 207, + 27, + 128, + 131, + 28, + 255, + 61, + 109, + 194, + 182, + 119, + 7, + 120, + 173, + 13, + 10, + 145, + 208, + 62, + 184, + 85, + 54, + 150, + 128, + 15, + 132, + 49, + 29, + 51, + 115, + 2, + 81, + 157, + 16, + 54, + 254, + 170, + 184, + 200, + 235, + 132, + 88, + 130, + 197, + 240 + ], + "tag": [ + 93, + 228, + 239, + 103, + 191, + 136, + 150, + 251, + 232, + 44, + 1, + 220, + 160, + 65, + 213, + 144 + ] + }, + { + "key": [ + 28, + 118, + 144, + 213, + 216, + 69, + 252, + 234, + 187, + 162, + 39, + 177, + 28, + 162, + 33, + 244, + 214, + 211, + 2, + 35, + 54, + 65, + 1, + 109, + 156, + 211, + 161, + 88, + 195, + 227, + 96, + 23 + ], + "nonce": [ + 147, + 188, + 168, + 222, + 107, + 17, + 164, + 131, + 12, + 95, + 95, + 100 + ], + "aad": [], + "plaintext": [ + 60, + 121, + 163, + 152, + 120, + 166, + 5, + 243, + 172, + 99, + 162, + 86, + 246, + 140, + 138, + 102, + 54, + 156, + 195, + 205, + 122, + 246, + 128, + 209, + 150, + 146, + 180, + 133, + 167, + 186, + 88, + 206, + 29, + 83, + 103, + 7, + 197, + 94, + 218, + 91, + 37, + 108, + 139, + 41, + 187, + 240, + 180, + 203, + 235, + 79, + 196 + ], + "ciphertext": [ + 201, + 228, + 134, + 132, + 223, + 19, + 175, + 204, + 219, + 29, + 156, + 234, + 164, + 131, + 117, + 144, + 34, + 229, + 156, + 49, + 17, + 24, + 140, + 30, + 206, + 176, + 46, + 175, + 48, + 128, + 53, + 176, + 66, + 141, + 184, + 38, + 222, + 134, + 45, + 146, + 90, + 60, + 85, + 175, + 11, + 97, + 253, + 143, + 9, + 167, + 77 + ], + "tag": [ + 143, + 87, + 126, + 135, + 48, + 193, + 152, + 88, + 202, + 216, + 224, + 18, + 79, + 49, + 29, + 217 + ] + }, + { + "key": [ + 219, + 219, + 81, + 50, + 241, + 38, + 230, + 44, + 229, + 183, + 75, + 248, + 90, + 42, + 195, + 59, + 39, + 101, + 136, + 163, + 252, + 145, + 209, + 187, + 92, + 116, + 5, + 161, + 191, + 104, + 65, + 139 + ], + "nonce": [ + 100, + 249, + 225, + 100, + 137, + 153, + 94, + 26, + 153, + 86, + 129, + 24 + ], + "aad": [], + "plaintext": [ + 178, + 116, + 10, + 61, + 86, + 71, + 170, + 90, + 174, + 185, + 138, + 46, + 123, + 191, + 49, + 237, + 174, + 161, + 235, + 172, + 214, + 58, + 217, + 107, + 78, + 38, + 136, + 241, + 255, + 8, + 175, + 142, + 228, + 7, + 27, + 242, + 105, + 65, + 197, + 23, + 215, + 69, + 35, + 102, + 140, + 161, + 249, + 223, + 219, + 202, + 171 + ], + "ciphertext": [ + 229, + 254, + 195, + 98, + 210, + 106, + 18, + 134, + 183, + 253, + 46, + 192, + 250, + 135, + 96, + 23, + 67, + 124, + 123, + 206, + 36, + 34, + 147, + 255, + 3, + 215, + 44, + 47, + 50, + 29, + 158, + 57, + 49, + 106, + 106, + 167, + 64, + 74, + 101, + 204, + 216, + 72, + 144, + 194, + 245, + 39, + 193, + 35, + 43, + 88, + 213 + ], + "tag": [ + 223, + 165, + 145, + 238, + 35, + 114, + 105, + 151, + 88, + 210, + 204, + 67, + 191, + 203, + 210, + 186 + ] + }, + { + "key": [ + 132, + 51, + 168, + 95, + 22, + 199, + 201, + 33, + 71, + 108, + 131, + 208, + 66, + 203, + 113, + 62, + 177, + 26, + 131, + 252, + 12, + 255, + 227, + 29, + 222, + 151, + 144, + 127, + 6, + 11, + 78, + 233 + ], + "nonce": [ + 85, + 255, + 200, + 95, + 253, + 28, + 222, + 168, + 184, + 196, + 131, + 130 + ], + "aad": [], + "plaintext": [ + 35, + 188, + 57, + 131, + 186, + 91, + 59, + 233, + 28, + 138, + 106, + 161, + 72, + 169, + 153, + 149, + 36, + 30, + 233, + 232, + 44, + 228, + 78, + 17, + 132, + 190, + 183, + 66, + 175, + 251, + 228, + 143, + 84, + 92, + 154, + 152, + 4, + 128, + 207, + 31, + 171, + 117, + 138, + 70, + 228, + 113, + 30, + 169, + 38, + 116, + 102 + ], + "ciphertext": [ + 47, + 75, + 220, + 123, + 139, + 140, + 236, + 24, + 99, + 227, + 20, + 88, + 113, + 85, + 71, + 120, + 196, + 57, + 99, + 181, + 39, + 248, + 65, + 59, + 185, + 119, + 153, + 53, + 193, + 56, + 163, + 77, + 134, + 215, + 199, + 106, + 158, + 106, + 246, + 137, + 144, + 47, + 49, + 97, + 145, + 225, + 47, + 52, + 18, + 106, + 66 + ], + "tag": [ + 125, + 198, + 49, + 86, + 177, + 44, + 152, + 104, + 230, + 185, + 165, + 132, + 61, + 242, + 215, + 158 + ] + }, + { + "key": [ + 93, + 123, + 245, + 84, + 87, + 146, + 156, + 101, + 228, + 242, + 169, + 124, + 189, + 204, + 155, + 67, + 36, + 5, + 177, + 53, + 36, + 81, + 204, + 201, + 88, + 188, + 238, + 188, + 229, + 87, + 73, + 29 + ], + "nonce": [ + 244, + 90, + 231, + 12, + 38, + 78, + 214, + 225, + 204, + 19, + 41, + 120 + ], + "aad": [], + "plaintext": [ + 186, + 90, + 194, + 161, + 109, + 132, + 176, + 223, + 90, + 110, + 64, + 240, + 151, + 217, + 212, + 75, + 242, + 29, + 225, + 252, + 236, + 6, + 228, + 199, + 133, + 116, + 99, + 150, + 62, + 92, + 101, + 201, + 54, + 211, + 125, + 120, + 134, + 127, + 37, + 60, + 226, + 86, + 144, + 129, + 27, + 243, + 148, + 99, + 229, + 112, + 42 + ], + "ciphertext": [ + 71, + 193, + 111, + 135, + 235, + 240, + 11, + 163, + 229, + 4, + 22, + 180, + 75, + 153, + 151, + 108, + 45, + 181, + 121, + 66, + 60, + 58, + 52, + 32, + 71, + 156, + 71, + 124, + 213, + 239, + 87, + 98, + 28, + 156, + 12, + 238, + 117, + 32, + 172, + 181, + 94, + 115, + 156, + 197, + 67, + 91, + 200, + 102, + 90, + 42, + 12 + ], + "tag": [ + 69, + 96, + 84, + 236, + 181, + 92, + 247, + 231, + 95, + 149, + 67, + 222, + 242, + 198, + 233, + 140 + ] + }, + { + "key": [ + 89, + 95, + 37, + 156, + 85, + 171, + 224, + 10, + 224, + 117, + 53, + 202, + 93, + 155, + 9, + 214, + 239, + 185, + 247, + 233, + 171, + 182, + 70, + 5, + 195, + 55, + 172, + 189, + 107, + 20, + 252, + 126 + ], + "nonce": [ + 146, + 242, + 88, + 7, + 29, + 121, + 175, + 62, + 99, + 103, + 34, + 133 + ], + "aad": [], + "plaintext": [ + 166, + 254, + 227, + 62, + 177, + 16, + 162, + 215, + 105, + 187, + 197, + 43, + 15, + 54, + 150, + 156, + 40, + 120, + 116, + 246, + 101, + 104, + 20, + 119, + 162, + 95, + 196, + 196, + 128, + 21, + 197, + 65, + 251, + 226, + 57, + 65, + 51, + 186, + 73, + 10, + 52, + 238, + 45, + 214, + 123, + 137, + 129, + 119, + 132, + 154, + 145 + ], + "ciphertext": [ + 187, + 202, + 74, + 158, + 9, + 174, + 150, + 144, + 192, + 246, + 248, + 212, + 5, + 229, + 61, + 204, + 214, + 102, + 170, + 156, + 95, + 161, + 60, + 135, + 88, + 188, + 48, + 171, + 225, + 221, + 209, + 188, + 206, + 13, + 54, + 161, + 234, + 170, + 175, + 254, + 242, + 12, + 211, + 197, + 151, + 11, + 150, + 115, + 248, + 166, + 92 + ], + "tag": [ + 38, + 204, + 236, + 185, + 151, + 111, + 214, + 172, + 156, + 44, + 15, + 55, + 44, + 82, + 200, + 33 + ] + }, + { + "key": [ + 37, + 18, + 39, + 247, + 44, + 72, + 26, + 126, + 6, + 76, + 187, + 170, + 84, + 137, + 188, + 133, + 215, + 64, + 193, + 230, + 237, + 234, + 34, + 130, + 21, + 69, + 7, + 135, + 126, + 213, + 104, + 25 + ], + "nonce": [ + 219, + 113, + 147, + 217, + 205, + 122, + 236, + 237, + 153, + 6, + 42, + 28 + ], + "aad": [], + "plaintext": [ + 204, + 207, + 253, + 88, + 253, + 237, + 126, + 88, + 148, + 129, + 218, + 24, + 190, + 236, + 81, + 86, + 36, + 129, + 244, + 178, + 140, + 41, + 68, + 129, + 156, + 55, + 247, + 18, + 93, + 86, + 220, + 236, + 160, + 239, + 11, + 182, + 247, + 215, + 238, + 181, + 183, + 162, + 189, + 107, + 85, + 18, + 84, + 233, + 237, + 255, + 58 + ], + "ciphertext": [ + 28, + 192, + 141, + 117, + 160, + 61, + 50, + 238, + 154, + 122, + 232, + 142, + 0, + 113, + 64, + 109, + 190, + 225, + 195, + 6, + 56, + 60, + 244, + 23, + 49, + 243, + 197, + 71, + 243, + 55, + 123, + 146, + 247, + 204, + 40, + 179, + 193, + 6, + 102, + 1, + 245, + 71, + 83, + 251, + 214, + 137, + 175, + 93, + 188, + 84, + 72 + ], + "tag": [ + 160, + 199, + 183, + 68, + 66, + 41, + 168, + 207, + 239, + 36, + 163, + 30, + 226, + 222, + 153, + 97 + ] + }, + { + "key": [ + 242, + 86, + 80, + 79, + 199, + 143, + 255, + 113, + 57, + 196, + 46, + 209, + 81, + 14, + 223, + 154, + 197, + 222, + 39, + 218, + 112, + 100, + 1, + 170, + 156, + 103, + 253, + 152, + 45, + 67, + 89, + 17 + ], + "nonce": [ + 138, + 220, + 242, + 214, + 120, + 171, + 206, + 249, + 221, + 69, + 232, + 249 + ], + "aad": [], + "plaintext": [ + 209, + 182, + 219, + 43, + 44, + 129, + 117, + 17, + 112, + 217, + 225, + 163, + 153, + 151, + 83, + 158, + 62, + 146, + 108, + 164, + 164, + 50, + 152, + 205, + 211, + 235, + 111, + 232, + 103, + 139, + 80, + 140, + 219, + 144, + 168, + 169, + 65, + 113, + 171, + 226, + 103, + 56, + 148, + 64, + 94, + 218, + 89, + 119, + 105, + 77, + 122 + ], + "ciphertext": [ + 118, + 32, + 93, + 99, + 185, + 197, + 20, + 78, + 93, + 170, + 138, + 199, + 229, + 31, + 25, + 250, + 150, + 231, + 26, + 49, + 6, + 171, + 119, + 155, + 103, + 168, + 53, + 138, + 181, + 214, + 14, + 247, + 113, + 151, + 112, + 98, + 102, + 226, + 194, + 20, + 19, + 131, + 52, + 163, + 237, + 102, + 206, + 204, + 181, + 166, + 205 + ], + "tag": [ + 193, + 254, + 83, + 207, + 133, + 251, + 203, + 255, + 147, + 44, + 110, + 29, + 2, + 110, + 161, + 213 + ] + }, + { + "key": [ + 33, + 210, + 150, + 51, + 95, + 88, + 81, + 90, + 144, + 83, + 122, + 108, + 163, + 163, + 133, + 54, + 235, + 161, + 248, + 153, + 162, + 146, + 116, + 71, + 163, + 190, + 63, + 10, + 221, + 112, + 190, + 165 + ], + "nonce": [ + 43, + 227, + 173, + 22, + 79, + 203, + 207, + 142, + 230, + 112, + 133, + 53 + ], + "aad": [], + "plaintext": [ + 173, + 39, + 134, + 80, + 9, + 40, + 131, + 211, + 72, + 190, + 99, + 233, + 145, + 35, + 30, + 248, + 87, + 100, + 30, + 94, + 252, + 12, + 171, + 155, + 178, + 143, + 54, + 11, + 236, + 195, + 193, + 3, + 210, + 121, + 71, + 133, + 2, + 79, + 24, + 123, + 234, + 249, + 102, + 91, + 152, + 99, + 128, + 201, + 41, + 70, + 167 + ], + "ciphertext": [ + 184, + 82, + 174, + 186, + 112, + 78, + 157, + 137, + 68, + 139, + 161, + 128, + 160, + 191, + 222, + 158, + 151, + 90, + 33, + 204, + 7, + 61, + 12, + 2, + 112, + 18, + 21, + 135, + 46, + 215, + 70, + 159, + 0, + 254, + 52, + 146, + 148, + 186, + 45, + 114, + 191, + 60, + 119, + 128, + 183, + 44, + 118, + 16, + 27, + 161, + 72 + ], + "tag": [ + 189, + 214, + 215, + 8, + 180, + 90, + 229, + 76, + 216, + 72, + 46, + 76, + 84, + 128, + 163, + 193 + ] + }, + { + "key": [ + 212, + 35, + 128, + 88, + 14, + 52, + 145, + 221, + 251, + 192, + 236, + 50, + 66, + 78, + 58, + 40, + 28, + 190, + 113, + 170, + 117, + 5, + 255, + 90, + 184, + 210, + 78, + 100, + 251, + 228, + 117, + 24 + ], + "nonce": [ + 251, + 237, + 136, + 222, + 97, + 214, + 5, + 167, + 19, + 127, + 254, + 178 + ], + "aad": [], + "plaintext": [ + 72, + 135, + 166, + 239, + 148, + 120, + 136, + 191, + 128, + 228, + 196, + 13, + 151, + 105, + 101, + 5, + 6, + 235, + 79, + 74, + 95, + 210, + 65, + 180, + 44, + 144, + 70, + 227, + 162, + 207, + 17, + 157, + 176, + 2, + 248, + 154, + 158, + 186, + 29, + 17, + 183, + 163, + 120, + 190, + 107, + 39, + 214, + 248, + 252, + 134, + 201 + ], + "ciphertext": [ + 135, + 170, + 39, + 249, + 97, + 135, + 206, + 39, + 226, + 108, + 175, + 113, + 186, + 91, + 164, + 227, + 119, + 5, + 253, + 134, + 202, + 146, + 145, + 234, + 104, + 214, + 198, + 249, + 3, + 2, + 145, + 205, + 191, + 245, + 139, + 255, + 30, + 103, + 65, + 89, + 11, + 38, + 131, + 103, + 225, + 241, + 184, + 196, + 185, + 76, + 212 + ], + "tag": [ + 209, + 105, + 10, + 111, + 228, + 3, + 196, + 117, + 79, + 211, + 119, + 61, + 137, + 57, + 94, + 205 + ] + }, + { + "key": [ + 85, + 17, + 114, + 126, + 205, + 146, + 172, + 236, + 81, + 13, + 93, + 140, + 12, + 73, + 179, + 202, + 172, + 210, + 20, + 4, + 49, + 207, + 81, + 224, + 148, + 55, + 235, + 216, + 202, + 130, + 226, + 206 + ], + "nonce": [ + 174, + 128, + 208, + 54, + 150, + 226, + 52, + 100, + 200, + 129, + 204, + 255 + ], + "aad": [], + "plaintext": [ + 24, + 75, + 8, + 102, + 70, + 239, + 149, + 17, + 28, + 203, + 61, + 49, + 159, + 49, + 36, + 244, + 212, + 210, + 65, + 249, + 215, + 49, + 206, + 38, + 102, + 46, + 163, + 158, + 67, + 69, + 126, + 48, + 176, + 189, + 115, + 155, + 93, + 93, + 188, + 235, + 53, + 60, + 224, + 195, + 100, + 122, + 58, + 76, + 135, + 227, + 176 + ], + "ciphertext": [ + 170, + 40, + 203, + 37, + 118, + 152, + 150, + 61, + 252, + 62, + 63, + 232, + 99, + 104, + 216, + 129, + 172, + 6, + 110, + 184, + 238, + 33, + 90, + 124, + 14, + 215, + 46, + 77, + 8, + 29, + 176, + 185, + 64, + 7, + 30, + 46, + 100, + 255, + 98, + 4, + 150, + 13, + 168, + 227, + 70, + 77, + 175, + 76, + 183, + 243, + 123 + ], + "tag": [ + 193, + 87, + 138, + 166, + 227, + 50, + 94, + 228, + 181, + 233, + 251, + 158, + 230, + 42, + 112, + 40 + ] + }, + { + "key": [ + 212, + 143, + 48, + 114, + 187, + 213, + 53, + 162, + 223, + 10, + 40, + 100, + 254, + 179, + 59, + 72, + 133, + 150, + 205, + 82, + 58, + 209, + 98, + 59, + 28, + 239, + 231, + 184, + 203, + 239, + 207, + 74 + ], + "nonce": [ + 187, + 242, + 165, + 55, + 210, + 133, + 68, + 77, + 148, + 245, + 233, + 68 + ], + "aad": [], + "plaintext": [ + 6, + 12, + 88, + 91, + 213, + 21, + 57, + 175, + 221, + 143, + 248, + 113, + 68, + 13, + 179, + 107, + 253, + 206, + 51, + 183, + 240, + 57, + 50, + 27, + 10, + 99, + 39, + 58, + 49, + 139, + 210, + 83, + 117, + 162, + 217, + 97, + 91, + 35, + 108, + 254, + 99, + 214, + 39, + 198, + 197, + 97, + 83, + 93, + 223, + 182, + 189 + ], + "ciphertext": [ + 153, + 61, + 93, + 105, + 44, + 33, + 133, + 112, + 210, + 148, + 171, + 144, + 213, + 247, + 170, + 104, + 61, + 192, + 228, + 112, + 239, + 172, + 39, + 154, + 119, + 96, + 64, + 243, + 180, + 147, + 134, + 129, + 63, + 104, + 176, + 219, + 106, + 122, + 239, + 89, + 2, + 92, + 195, + 133, + 32, + 251, + 49, + 138, + 30, + 172, + 85 + ], + "tag": [ + 140, + 216, + 8, + 67, + 138, + 143, + 91, + 106, + 105, + 255, + 58, + 226, + 85, + 191, + 44, + 178 + ] + }, + { + "key": [ + 95, + 224, + 28, + 75, + 175, + 1, + 203, + 224, + 119, + 150, + 213, + 170, + 239, + 110, + 193, + 244, + 81, + 147, + 169, + 138, + 34, + 53, + 148, + 174, + 79, + 14, + 244, + 149, + 46, + 130, + 227, + 48 + ], + "nonce": [ + 189, + 88, + 115, + 33, + 86, + 108, + 127, + 26, + 93, + 216, + 101, + 45 + ], + "aad": [ + 144, + 19, + 97, + 120, + 23, + 221, + 169, + 71, + 225, + 53, + 238, + 109, + 211, + 101, + 51, + 130 + ], + "plaintext": [ + 136, + 29, + 198, + 199, + 165, + 212, + 80, + 159, + 60, + 75, + 210, + 218, + 171, + 8, + 241, + 101, + 221, + 194, + 4, + 72, + 154, + 168, + 19, + 69, + 98, + 164, + 234, + 195, + 208, + 188, + 173, + 121, + 101, + 132, + 123, + 16, + 39, + 51, + 187, + 99, + 209, + 229, + 197, + 152, + 236, + 224, + 195, + 229, + 218, + 221, + 221 + ], + "ciphertext": [ + 22, + 227, + 117, + 180, + 151, + 59, + 51, + 157, + 63, + 116, + 108, + 28, + 90, + 86, + 139, + 199, + 82, + 110, + 144, + 157, + 223, + 241, + 225, + 156, + 149, + 201, + 74, + 108, + 207, + 242, + 16, + 201, + 164, + 164, + 6, + 121, + 222, + 87, + 96, + 195, + 150, + 172, + 14, + 44, + 235, + 18, + 52, + 249, + 245, + 254, + 38 + ], + "tag": [ + 171, + 211, + 210, + 109, + 101, + 166, + 39, + 95, + 122, + 79, + 86, + 180, + 34, + 172, + 171, + 73 + ] + }, + { + "key": [ + 136, + 90, + 155, + 18, + 65, + 55, + 228, + 11, + 208, + 246, + 151, + 119, + 19, + 23, + 228, + 1, + 206, + 54, + 50, + 126, + 97, + 168, + 249, + 208, + 184, + 15, + 71, + 152, + 243, + 10, + 115, + 29 + ], + "nonce": [ + 190, + 235, + 194, + 245, + 162, + 111, + 210, + 202, + 177, + 233, + 195, + 149 + ], + "aad": [ + 46, + 139, + 221, + 227, + 34, + 88, + 165, + 252, + 216, + 205, + 33, + 3, + 125, + 5, + 69, + 235 + ], + "plaintext": [ + 66, + 126, + 197, + 104, + 173, + 131, + 103, + 194, + 2, + 245, + 217, + 153, + 146, + 64, + 249, + 153, + 76, + 193, + 19, + 80, + 1, + 84, + 247, + 244, + 158, + 156, + 162, + 124, + 200, + 21, + 65, + 67, + 184, + 85, + 35, + 139, + 202, + 92, + 123, + 214, + 217, + 133, + 43, + 78, + 235, + 212, + 30, + 78, + 185, + 143, + 22 + ], + "ciphertext": [ + 161, + 216, + 58, + 171, + 104, + 100, + 219, + 70, + 61, + 157, + 124, + 34, + 65, + 148, + 98, + 189, + 224, + 116, + 3, + 85, + 193, + 20, + 124, + 98, + 180, + 196, + 242, + 60, + 238, + 175, + 101, + 177, + 107, + 135, + 59, + 28, + 199, + 230, + 152, + 223, + 246, + 227, + 209, + 156, + 249, + 218, + 51, + 232, + 203, + 203, + 167 + ], + "tag": [ + 79, + 219, + 253, + 82, + 16, + 175, + 163, + 85, + 110, + 192, + 253, + 196, + 139, + 152, + 225, + 235 + ] + }, + { + "key": [ + 33, + 193, + 144, + 226, + 181, + 46, + 39, + 177, + 7, + 247, + 162, + 75, + 145, + 58, + 52, + 189, + 91, + 112, + 34, + 6, + 12, + 90, + 77, + 236, + 154, + 178, + 137, + 255, + 138, + 230, + 126, + 45 + ], + "nonce": [ + 178, + 138, + 97, + 230, + 193, + 223, + 167, + 247, + 109, + 8, + 96, + 99 + ], + "aad": [ + 216, + 6, + 87, + 55, + 125, + 219, + 190, + 209, + 249, + 184, + 216, + 36, + 179, + 196, + 216, + 118 + ], + "plaintext": [ + 78, + 27, + 149, + 40, + 207, + 70, + 177, + 221, + 136, + 152, + 88, + 211, + 144, + 77, + 65, + 211, + 23, + 77, + 203, + 34, + 89, + 35, + 249, + 35, + 216, + 10, + 219, + 254, + 110, + 236, + 20, + 75, + 29, + 78, + 179, + 105, + 13, + 11, + 133, + 25, + 201, + 155, + 234, + 238, + 37, + 187, + 80, + 253, + 45, + 20, + 143 + ], + "ciphertext": [ + 113, + 38, + 250, + 128, + 122, + 166, + 182, + 26, + 96, + 149, + 143, + 228, + 204, + 134, + 130, + 187, + 37, + 110, + 91, + 189, + 196, + 153, + 208, + 74, + 108, + 170, + 129, + 178, + 63, + 158, + 103, + 211, + 218, + 76, + 241, + 153, + 75, + 90, + 142, + 204, + 123, + 206, + 100, + 24, + 100, + 208, + 81, + 154, + 101, + 9, + 205 + ], + "tag": [ + 211, + 233, + 101, + 104, + 242, + 205, + 26, + 72, + 119, + 30, + 228, + 246, + 122, + 208, + 66, + 193 + ] + }, + { + "key": [ + 17, + 195, + 58, + 227, + 118, + 128, + 19, + 12, + 81, + 237, + 17, + 191, + 175, + 15, + 203, + 110, + 212, + 252, + 125, + 144, + 63, + 244, + 50, + 184, + 17, + 118, + 61, + 44, + 126, + 248, + 58, + 51 + ], + "nonce": [ + 15, + 34, + 77, + 38, + 219, + 246, + 50, + 206, + 189, + 206, + 59, + 139 + ], + "aad": [ + 222, + 232, + 3, + 115, + 47, + 246, + 98, + 203, + 169, + 248, + 97, + 34, + 127, + 139, + 103, + 207 + ], + "plaintext": [ + 248, + 162, + 175, + 254, + 90, + 126, + 103, + 242, + 198, + 38, + 34, + 228, + 165, + 104, + 4, + 180, + 142, + 82, + 157, + 31, + 175, + 144, + 150, + 249, + 68, + 9, + 34, + 65, + 41, + 146, + 28, + 228, + 106, + 237, + 137, + 141, + 213, + 57, + 23, + 70, + 232, + 23, + 14, + 5, + 249, + 30, + 5, + 36, + 22, + 102, + 37 + ], + "ciphertext": [ + 56, + 86, + 85, + 131, + 117, + 195, + 99, + 178, + 94, + 143, + 158, + 158, + 46, + 182, + 60, + 240, + 231, + 106, + 28, + 110, + 34, + 136, + 147, + 199, + 178, + 45, + 164, + 166, + 155, + 104, + 37, + 40, + 180, + 164, + 202, + 43, + 153, + 231, + 165, + 55, + 57, + 14, + 45, + 30, + 5, + 166, + 143, + 62, + 57, + 196, + 233 + ], + "tag": [ + 155, + 18, + 105, + 27, + 32, + 2, + 202, + 146, + 39, + 3, + 92, + 104, + 234, + 148, + 30, + 243 + ] + }, + { + "key": [ + 59, + 41, + 23, + 148, + 251, + 185, + 21, + 44, + 62, + 79, + 77, + 228, + 96, + 138, + 145, + 55, + 210, + 119, + 189, + 101, + 31, + 151, + 231, + 56, + 175, + 170, + 84, + 141, + 151, + 180, + 236, + 96 + ], + "nonce": [ + 77, + 28, + 105, + 198, + 218, + 150, + 192, + 133, + 211, + 20, + 34, + 186 + ], + "aad": [ + 243, + 165, + 250, + 97, + 164, + 233, + 135, + 65, + 58, + 143, + 171, + 74, + 165, + 29, + 137, + 93 + ], + "plaintext": [ + 33, + 179, + 202, + 31, + 71, + 160, + 199, + 246, + 235, + 208, + 151, + 237, + 166, + 157, + 158, + 91, + 95, + 191, + 92, + 36, + 215, + 129, + 101, + 128, + 3, + 207, + 212, + 67, + 174, + 112, + 150, + 190, + 25, + 225, + 205, + 60, + 20, + 254, + 151, + 56, + 239, + 176, + 8, + 71, + 105, + 127, + 204, + 180, + 102, + 174, + 27 + ], + "ciphertext": [ + 108, + 20, + 57, + 205, + 44, + 181, + 100, + 231, + 148, + 79, + 213, + 47, + 49, + 110, + 132, + 174, + 255, + 195, + 253, + 128, + 36, + 223, + 90, + 125, + 149, + 168, + 124, + 77, + 49, + 160, + 248, + 234, + 23, + 242, + 20, + 66, + 199, + 9, + 168, + 59, + 50, + 109, + 6, + 125, + 95, + 142, + 48, + 5, + 235, + 226, + 42 + ], + "tag": [ + 229, + 128, + 72, + 242, + 193, + 248, + 6, + 224, + 149, + 82, + 194, + 229, + 205, + 241, + 185, + 217 + ] + }, + { + "key": [ + 142, + 122, + 142, + 123, + 18, + 147, + 38, + 229, + 65, + 12, + 138, + 230, + 127, + 189, + 49, + 141, + 225, + 144, + 156, + 171, + 161, + 210, + 183, + 146, + 16, + 121, + 60, + 107, + 44, + 110, + 97, + 199 + ], + "nonce": [ + 142, + 72, + 81, + 63, + 221, + 151, + 24, + 97, + 239, + 123, + 93, + 195 + ], + "aad": [ + 128, + 187, + 102, + 164, + 114, + 112, + 149, + 182, + 194, + 1, + 251, + 61, + 130, + 176, + 252, + 245 + ], + "plaintext": [ + 239, + 107, + 65, + 69, + 145, + 1, + 57, + 41, + 54, + 49, + 219, + 135, + 160, + 215, + 120, + 42, + 29, + 149, + 219, + 86, + 142, + 133, + 117, + 152, + 18, + 133, + 130, + 232, + 145, + 75, + 79, + 167, + 192, + 60, + 27, + 131, + 229, + 98, + 74, + 46, + 180, + 195, + 64, + 200, + 173, + 126, + 103, + 54, + 163, + 231, + 0 + ], + "ciphertext": [ + 227, + 2, + 104, + 124, + 5, + 72, + 151, + 56, + 151, + 162, + 124, + 49, + 145, + 31, + 200, + 126, + 233, + 61, + 135, + 88, + 196, + 222, + 214, + 141, + 107, + 214, + 65, + 94, + 170, + 248, + 107, + 204, + 69, + 250, + 106, + 30, + 248, + 166, + 174, + 6, + 136, + 32, + 84, + 155, + 23, + 4, + 5, + 179, + 252, + 9, + 37 + ], + "tag": [ + 255, + 92, + 25, + 57, + 82, + 85, + 142, + 90, + 18, + 14, + 103, + 47, + 86, + 107, + 228, + 17 + ] + }, + { + "key": [ + 214, + 135, + 224, + 38, + 47, + 122, + 242, + 118, + 133, + 112, + 223, + 144, + 182, + 152, + 9, + 78, + 3, + 182, + 104, + 206, + 97, + 131, + 182, + 198, + 182, + 202, + 56, + 93, + 205, + 98, + 39, + 41 + ], + "nonce": [ + 80, + 246, + 144, + 79, + 45, + 132, + 102, + 218, + 163, + 60, + 36, + 97 + ], + "aad": [ + 232, + 250, + 153, + 67, + 41, + 41, + 214, + 111, + 16, + 32, + 90, + 211, + 233, + 89, + 33, + 81 + ], + "plaintext": [ + 121, + 227, + 6, + 125, + 148, + 70, + 78, + 1, + 154, + 124, + 138, + 241, + 11, + 83, + 173, + 245, + 176, + 148, + 38, + 211, + 95, + 34, + 87, + 195, + 203, + 175, + 254, + 31, + 247, + 32, + 86, + 92, + 7, + 231, + 122, + 238, + 240, + 111, + 157, + 3, + 162, + 53, + 48, + 83, + 153, + 32, + 115, + 164, + 237, + 31, + 200 + ], + "ciphertext": [ + 24, + 246, + 230, + 174, + 236, + 200, + 220, + 90, + 61, + 11, + 99, + 162, + 168, + 183, + 191, + 175, + 105, + 91, + 217, + 196, + 154, + 115, + 146, + 219, + 250, + 142, + 212, + 71, + 113, + 238, + 190, + 39, + 249, + 69, + 137, + 216, + 164, + 48, + 218, + 76, + 240, + 58, + 134, + 147, + 188, + 117, + 37, + 225, + 252, + 172, + 130 + ], + "tag": [ + 60, + 134, + 78, + 170, + 27, + 10, + 228, + 74, + 127, + 10, + 217, + 186, + 40, + 123, + 168, + 0 + ] + }, + { + "key": [ + 38, + 220, + 92, + 231, + 75, + 77, + 100, + 209, + 220, + 34, + 33, + 205, + 214, + 166, + 61, + 122, + 146, + 38, + 19, + 71, + 8, + 41, + 156, + 215, + 25, + 166, + 143, + 99, + 107, + 107, + 94, + 189 + ], + "nonce": [ + 2, + 148, + 197, + 79, + 244, + 237, + 48, + 120, + 34, + 34, + 200, + 52 + ], + "aad": [ + 42, + 159, + 179, + 38, + 249, + 139, + 190, + 45, + 44, + 245, + 123, + 174, + 158, + 203, + 239, + 247 + ], + "plaintext": [ + 174, + 76, + 127, + 4, + 13, + 58, + 95, + 241, + 8, + 226, + 147, + 129, + 231, + 160, + 131, + 2, + 33, + 213, + 55, + 139, + 19, + 184, + 126, + 240, + 112, + 60, + 50, + 118, + 134, + 211, + 10, + 240, + 4, + 144, + 45, + 77, + 219, + 89, + 213, + 120, + 127, + 236, + 234, + 71, + 49, + 234, + 168, + 4, + 36, + 67, + 213 + ], + "ciphertext": [ + 150, + 1, + 174, + 198, + 188, + 110, + 138, + 9, + 208, + 84, + 160, + 30, + 80, + 10, + 78, + 76, + 220, + 199, + 194, + 207, + 131, + 18, + 38, + 86, + 190, + 124, + 38, + 252, + 125, + 193, + 167, + 115, + 164, + 11, + 231, + 232, + 160, + 73, + 166, + 205, + 240, + 89, + 233, + 58, + 35, + 202, + 68, + 30, + 241, + 202, + 150 + ], + "tag": [ + 182, + 32, + 168, + 160, + 200, + 254, + 97, + 23, + 242, + 39, + 53, + 192, + 202, + 41, + 67, + 76 + ] + }, + { + "key": [ + 127, + 160, + 100, + 78, + 252, + 127, + 46, + 141, + 244, + 179, + 17, + 245, + 75, + 168, + 184, + 201, + 117, + 178, + 194, + 170, + 151, + 150, + 47, + 140, + 168, + 163, + 34, + 84, + 27, + 237, + 170, + 157 + ], + "nonce": [ + 94, + 119, + 78, + 69, + 160, + 126, + 235, + 151, + 33, + 115, + 68, + 18 + ], + "aad": [ + 106, + 214, + 115, + 218, + 168, + 196, + 18, + 191, + 40, + 14, + 163, + 155, + 160, + 217, + 182, + 212 + ], + "plaintext": [ + 132, + 209, + 199, + 84, + 85, + 228, + 197, + 116, + 25, + 169, + 215, + 138, + 144, + 239, + 194, + 50, + 193, + 121, + 81, + 127, + 233, + 74, + 255, + 83, + 164, + 184, + 247, + 87, + 93, + 181, + 175, + 98, + 127, + 61, + 0, + 128, + 6, + 242, + 22, + 236, + 252, + 73, + 171, + 141, + 168, + 146, + 127, + 245, + 220, + 57, + 89 + ], + "ciphertext": [ + 226, + 240, + 11, + 90, + 134, + 179, + 222, + 194, + 183, + 126, + 84, + 219, + 50, + 140, + 141, + 149, + 77, + 75, + 113, + 111, + 151, + 53, + 229, + 121, + 139, + 5, + 214, + 92, + 81, + 38, + 116, + 213, + 110, + 136, + 189, + 160, + 212, + 134, + 104, + 90, + 69, + 213, + 194, + 73, + 113, + 152, + 132, + 50, + 158, + 50, + 151 + ], + "tag": [ + 12, + 232, + 235, + 84, + 213, + 173, + 53, + 221, + 44, + 179, + 250, + 117, + 231, + 183, + 14, + 51 + ] + }, + { + "key": [ + 145, + 208, + 66, + 159, + 44, + 69, + 207, + 138, + 176, + 29, + 80, + 185, + 240, + 77, + 170, + 172, + 203, + 224, + 80, + 60, + 159, + 17, + 95, + 148, + 87, + 200, + 58, + 4, + 61, + 200, + 59, + 35 + ], + "nonce": [ + 52, + 64, + 29, + 141, + 146, + 46, + 235, + 172, + 24, + 41, + 242, + 46 + ], + "aad": [ + 27, + 41, + 222, + 147, + 33, + 174, + 188, + 63, + 249, + 209, + 194, + 80, + 122, + 238, + 128, + 233 + ], + "plaintext": [ + 214, + 0, + 216, + 42, + 60, + 32, + 201, + 71, + 146, + 54, + 41, + 89, + 222, + 68, + 12, + 147, + 17, + 154, + 113, + 138, + 199, + 73, + 250, + 136, + 170, + 96, + 111, + 201, + 156, + 176, + 43, + 76, + 169, + 186, + 149, + 141, + 40, + 220, + 133, + 240, + 82, + 60, + 153, + 216, + 47, + 67, + 245, + 140, + 95, + 151, + 155 + ], + "ciphertext": [ + 132, + 203, + 201, + 147, + 110, + 183, + 39, + 0, + 128, + 187, + 112, + 36, + 120, + 1, + 19, + 208, + 100, + 236, + 203, + 99, + 211, + 218, + 11, + 214, + 188, + 228, + 248, + 115, + 125, + 40, + 48, + 75, + 251, + 97, + 2, + 243, + 174, + 156, + 57, + 76, + 198, + 69, + 38, + 51, + 252, + 85, + 21, + 130, + 187, + 254, + 29 + ], + "tag": [ + 225, + 50, + 220, + 138, + 49, + 210, + 31, + 36, + 234, + 14, + 105, + 223, + 182, + 178, + 101, + 87 + ] + }, + { + "key": [ + 68, + 230, + 65, + 27, + 159, + 191, + 206, + 243, + 135, + 208, + 202, + 7, + 183, + 25, + 24, + 28, + 117, + 103, + 226, + 125, + 186, + 89, + 232, + 225, + 195, + 204, + 23, + 99, + 207, + 234, + 202, + 4 + ], + "nonce": [ + 37, + 161, + 207, + 217, + 123, + 216, + 230, + 61, + 229, + 214, + 89, + 116 + ], + "aad": [ + 75, + 23, + 81, + 176, + 116, + 171, + 100, + 157, + 39, + 253, + 63, + 44, + 77, + 126, + 227, + 58 + ], + "plaintext": [ + 219, + 40, + 165, + 146, + 177, + 243, + 96, + 60, + 40, + 121, + 145, + 166, + 156, + 198, + 78, + 172, + 221, + 98, + 4, + 100, + 69, + 168, + 186, + 64, + 103, + 87, + 95, + 18, + 85, + 61, + 225, + 85, + 208, + 106, + 155, + 64, + 221, + 245, + 143, + 236, + 86, + 200, + 23, + 22, + 135, + 185, + 203, + 84, + 177, + 243, + 70 + ], + "ciphertext": [ + 54, + 191, + 107, + 183, + 97, + 178, + 36, + 143, + 231, + 26, + 98, + 14, + 52, + 233, + 209, + 142, + 18, + 167, + 76, + 164, + 44, + 154, + 154, + 33, + 211, + 3, + 69, + 153, + 90, + 131, + 235, + 68, + 188, + 174, + 60, + 103, + 192, + 32, + 115, + 12, + 216, + 213, + 229, + 26, + 116, + 22, + 148, + 204, + 57, + 100, + 105 + ], + "tag": [ + 230, + 158, + 191, + 128, + 168, + 141, + 110, + 202, + 65, + 174, + 135, + 205, + 202, + 180, + 225, + 242 + ] + }, + { + "key": [ + 169, + 75, + 252, + 239, + 174, + 144, + 249, + 7, + 136, + 96, + 219, + 128, + 204, + 197, + 8, + 25, + 234, + 223, + 124, + 206, + 41, + 223, + 50, + 121, + 249, + 79, + 94, + 234, + 151, + 0, + 158, + 242 + ], + "nonce": [ + 244, + 129, + 188, + 183, + 245, + 218, + 41, + 110, + 148, + 84, + 255, + 120 + ], + "aad": [ + 159, + 128, + 216, + 69, + 87, + 120, + 24, + 223, + 155, + 169, + 132, + 238, + 85, + 42, + 226, + 3 + ], + "plaintext": [ + 151, + 208, + 199, + 223, + 202, + 179, + 42, + 56, + 111, + 81, + 217, + 46, + 137, + 51, + 62, + 200, + 78, + 236, + 213, + 82, + 230, + 141, + 20, + 207, + 72, + 183, + 80, + 103, + 191, + 14, + 25, + 70, + 173, + 3, + 165, + 208, + 99, + 184, + 82, + 202, + 5, + 60, + 146, + 144, + 136, + 175, + 69, + 208, + 136, + 74, + 136 + ], + "ciphertext": [ + 24, + 161, + 201, + 191, + 225, + 177, + 223, + 221, + 6, + 228, + 101, + 223, + 52, + 124, + 30, + 148, + 43, + 55, + 179, + 228, + 140, + 176, + 201, + 5, + 132, + 26, + 89, + 59, + 91, + 13, + 3, + 48, + 254, + 179, + 184, + 151, + 13, + 188, + 148, + 41, + 37, + 42, + 137, + 127, + 15, + 142, + 18, + 134, + 14, + 163, + 154 + ], + "tag": [ + 16, + 207, + 77, + 51, + 91, + 141, + 142, + 126, + 139, + 186, + 244, + 146, + 34, + 161, + 205, + 102 + ] + }, + { + "key": [ + 165, + 10, + 96, + 229, + 104, + 255, + 53, + 166, + 16, + 239, + 148, + 121, + 192, + 139, + 188, + 123, + 182, + 76, + 55, + 63, + 200, + 83, + 243, + 127, + 166, + 179, + 80, + 37, + 10, + 38, + 242, + 50 + ], + "nonce": [ + 90, + 218, + 29, + 74, + 202, + 136, + 61, + 123, + 214, + 250, + 134, + 159 + ], + "aad": [ + 204, + 122, + 122, + 84, + 27, + 231, + 166, + 209, + 184, + 70, + 53, + 76, + 182, + 165, + 113, + 230 + ], + "plaintext": [ + 158, + 164, + 78, + 114, + 161, + 210, + 19, + 149, + 205, + 129, + 210, + 13, + 176, + 88, + 22, + 68, + 16, + 16, + 239, + 216, + 248, + 17, + 183, + 91, + 177, + 67, + 171, + 71, + 245, + 94, + 239, + 206, + 78, + 236, + 95, + 96, + 111, + 165, + 217, + 139, + 38, + 13, + 126, + 93, + 244, + 167, + 71, + 76, + 189, + 133, + 153 + ], + "ciphertext": [ + 65, + 101, + 177, + 53, + 24, + 127, + 174, + 179, + 149, + 212, + 83, + 28, + 6, + 39, + 56, + 224, + 212, + 125, + 248, + 190, + 217, + 25, + 130, + 235, + 50, + 227, + 145, + 166, + 179, + 113, + 31, + 17, + 123, + 111, + 174, + 10, + 253, + 231, + 145, + 222, + 62, + 114, + 252, + 249, + 109, + 43, + 83, + 255, + 26, + 98, + 26 + ], + "tag": [ + 226, + 203, + 254, + 162, + 16, + 5, + 133, + 178, + 203, + 229, + 16, + 125, + 161, + 127, + 247, + 122 + ] + }, + { + "key": [ + 95, + 243, + 49, + 20, + 97, + 210, + 71, + 206, + 177, + 234, + 245, + 145, + 41, + 47, + 203, + 165, + 67, + 8, + 221, + 52, + 132, + 253, + 24, + 81, + 224, + 154, + 18, + 184, + 246, + 102, + 63, + 193 + ], + "nonce": [ + 97, + 175, + 46, + 106, + 236, + 24, + 49, + 41, + 207, + 5, + 60, + 43 + ], + "aad": [ + 94, + 175, + 237, + 102, + 116, + 242, + 174, + 131, + 57, + 125, + 249, + 35, + 224, + 89, + 219, + 73 + ], + "plaintext": [ + 146, + 13, + 248, + 178, + 136, + 138, + 116, + 2, + 46, + 222, + 105, + 25, + 237, + 11, + 244, + 140, + 207, + 81, + 227, + 149, + 254, + 91, + 250, + 105, + 166, + 32, + 159, + 249, + 164, + 102, + 116, + 2, + 78, + 170, + 79, + 67, + 174, + 44, + 147, + 55, + 48, + 185, + 253, + 200, + 173, + 33, + 97, + 48, + 68, + 124, + 200 + ], + "ciphertext": [ + 14, + 53, + 225, + 32, + 129, + 104, + 182, + 57, + 224, + 18, + 223, + 57, + 139, + 200, + 191, + 43, + 25, + 176, + 141, + 70, + 175, + 3, + 83, + 205, + 120, + 246, + 209, + 183, + 174, + 20, + 230, + 34, + 76, + 29, + 166, + 253, + 201, + 67, + 59, + 23, + 31, + 28, + 210, + 181, + 18, + 213, + 241, + 172, + 216, + 79, + 3 + ], + "tag": [ + 91, + 199, + 126, + 176, + 46, + 77, + 81, + 226, + 1, + 148, + 70, + 180, + 104, + 73, + 141, + 14 + ] + }, + { + "key": [ + 66, + 233, + 53, + 71, + 238, + 231, + 225, + 142, + 201, + 98, + 13, + 211, + 220, + 14, + 43, + 28, + 243, + 229, + 212, + 72, + 25, + 138, + 144, + 45, + 237, + 63, + 147, + 93, + 169, + 211, + 91, + 51 + ], + "nonce": [ + 224, + 46, + 18, + 186, + 146, + 166, + 4, + 106, + 241, + 26, + 223, + 14 + ], + "aad": [ + 172, + 61, + 83, + 105, + 129, + 227, + 202, + 188, + 129, + 33, + 22, + 70, + 225, + 79, + 47, + 146 + ], + "plaintext": [ + 108, + 55, + 4, + 179, + 37, + 39, + 172, + 227, + 213, + 35, + 102, + 135, + 196, + 169, + 138, + 26, + 213, + 164, + 248, + 60, + 4, + 175, + 47, + 98, + 201, + 232, + 126, + 127, + 61, + 4, + 105, + 50, + 121, + 25, + 216, + 16, + 187, + 108, + 68, + 253, + 60, + 155, + 20, + 104, + 82, + 88, + 58, + 68, + 237, + 47, + 60 + ], + "ciphertext": [ + 139, + 101, + 6, + 175, + 112, + 58, + 227, + 21, + 142, + 182, + 30, + 47, + 156, + 43, + 99, + 222, + 64, + 59, + 46, + 188, + 107, + 30, + 103, + 89, + 206, + 185, + 156, + 8, + 170, + 102, + 203, + 7, + 209, + 217, + 19, + 172, + 74, + 205, + 122, + 249, + 185, + 224, + 59, + 58, + 246, + 2, + 188, + 175, + 43, + 182, + 94 + ], + "tag": [ + 166, + 206, + 44, + 203, + 35, + 111, + 201, + 158, + 135, + 183, + 108, + 196, + 18, + 167, + 144, + 49 + ] + }, + { + "key": [ + 36, + 80, + 26, + 211, + 132, + 228, + 115, + 150, + 61, + 71, + 110, + 220, + 254, + 8, + 32, + 82, + 55, + 172, + 253, + 73, + 181, + 184, + 243, + 56, + 87, + 248, + 17, + 78, + 134, + 63, + 236, + 127 + ], + "nonce": [ + 159, + 241, + 133, + 99, + 185, + 120, + 236, + 40, + 27, + 63, + 39, + 148 + ], + "aad": [ + 173, + 181, + 236, + 114, + 12, + 207, + 152, + 152, + 80, + 0, + 40, + 191, + 52, + 175, + 204, + 188, + 172, + 161, + 38, + 239 + ], + "plaintext": [ + 39, + 243, + 72, + 249, + 205, + 192, + 197, + 189, + 94, + 102, + 177, + 204, + 182, + 58, + 217, + 32, + 255, + 34, + 25, + 209, + 78, + 141, + 99, + 27, + 56, + 114, + 38, + 92, + 241, + 23, + 238, + 134, + 117, + 122, + 204, + 177, + 88, + 189, + 154, + 187, + 56, + 104, + 253, + 192, + 208, + 176, + 116, + 181, + 240, + 27, + 44 + ], + "ciphertext": [ + 235, + 124, + 183, + 84, + 200, + 36, + 232, + 217, + 111, + 124, + 109, + 155, + 118, + 199, + 210, + 111, + 184, + 116, + 255, + 191, + 29, + 101, + 198, + 246, + 74, + 105, + 141, + 131, + 155, + 11, + 6, + 20, + 93, + 174, + 130, + 5, + 122, + 213, + 89, + 148, + 207, + 89, + 173, + 127, + 103, + 192, + 250, + 94, + 133, + 250, + 184 + ], + "tag": [ + 188, + 149, + 197, + 50, + 254, + 204, + 89, + 76, + 54, + 209, + 85, + 2, + 134, + 167, + 163, + 240 + ] + }, + { + "key": [ + 251, + 67, + 245, + 171, + 74, + 23, + 56, + 163, + 12, + 30, + 5, + 61, + 72, + 74, + 148, + 37, + 65, + 37, + 213, + 93, + 204, + 238, + 26, + 214, + 124, + 54, + 139, + 193, + 169, + 133, + 210, + 53 + ], + "nonce": [ + 159, + 187, + 95, + 130, + 82, + 219, + 11, + 202, + 33, + 241, + 194, + 48 + ], + "aad": [ + 152, + 248, + 174, + 23, + 53, + 195, + 159, + 115, + 46, + 44, + 190, + 225, + 21, + 109, + 171, + 235, + 133, + 78, + 199, + 162 + ], + "plaintext": [ + 52, + 183, + 151, + 187, + 130, + 37, + 14, + 35, + 197, + 231, + 150, + 219, + 44, + 55, + 228, + 136, + 179, + 185, + 157, + 27, + 152, + 28, + 234, + 94, + 91, + 12, + 97, + 160, + 179, + 154, + 219, + 107, + 214, + 239, + 31, + 80, + 114, + 46, + 46, + 79, + 129, + 17, + 92, + 252, + 245, + 63, + 132, + 46, + 42, + 108, + 8 + ], + "ciphertext": [ + 135, + 28, + 213, + 61, + 149, + 168, + 184, + 6, + 189, + 72, + 33, + 230, + 196, + 69, + 98, + 4, + 210, + 127, + 215, + 4, + 186, + 61, + 7, + 206, + 37, + 135, + 45, + 198, + 4, + 234, + 92, + 94, + 161, + 51, + 34, + 24, + 107, + 116, + 137, + 219, + 79, + 160, + 96, + 193, + 253, + 65, + 89, + 105, + 38, + 18, + 200 + ], + "tag": [ + 7, + 180, + 142, + 74, + 50, + 250, + 196, + 126, + 17, + 93, + 122, + 199, + 68, + 93, + 131, + 48 + ] + }, + { + "key": [ + 159, + 149, + 59, + 159, + 47, + 59, + 180, + 16, + 58, + 75, + 52, + 216, + 202, + 46, + 195, + 114, + 13, + 247, + 254, + 223, + 140, + 105, + 202, + 201, + 0, + 189, + 117, + 51, + 139, + 234, + 186, + 190 + ], + "nonce": [ + 235, + 115, + 26, + 224, + 78, + 57, + 243, + 235, + 136, + 204, + 119, + 250 + ], + "aad": [ + 212, + 74, + 7, + 216, + 105, + 172, + 13, + 137, + 177, + 82, + 98, + 161, + 232, + 225, + 170, + 116, + 240, + 155, + 203, + 130 + ], + "plaintext": [ + 59, + 128, + 213, + 172, + 18, + 186, + 157, + 173, + 157, + 159, + 243, + 10, + 115, + 115, + 38, + 116, + 225, + 28, + 158, + 223, + 155, + 176, + 87, + 253, + 28, + 106, + 220, + 151, + 207, + 108, + 95, + 163, + 238, + 134, + 144, + 173, + 76, + 81, + 177, + 11, + 59, + 213, + 218, + 154, + 40, + 230, + 39, + 92, + 190, + 40, + 203 + ], + "ciphertext": [ + 21, + 51, + 206, + 142, + 47, + 198, + 171, + 72, + 90, + 239, + 111, + 207, + 176, + 141, + 237, + 131, + 174, + 84, + 154, + 113, + 17, + 252, + 226, + 161, + 216, + 163, + 246, + 145, + 243, + 81, + 130, + 206, + 70, + 252, + 230, + 32, + 77, + 125, + 175, + 184, + 211, + 32, + 108, + 78, + 75, + 100, + 91, + 195, + 245, + 175, + 209 + ], + "tag": [ + 240, + 146, + 101, + 194, + 31, + 144, + 239, + 121, + 179, + 9, + 169, + 61, + 183, + 61, + 146, + 144 + ] + }, + { + "key": [ + 36, + 38, + 226, + 209, + 205, + 149, + 69, + 236, + 47, + 183, + 171, + 145, + 55, + 173, + 133, + 39, + 52, + 51, + 57, + 37, + 191, + 197, + 103, + 71, + 99, + 214, + 238, + 144, + 110, + 129, + 192, + 145 + ], + "nonce": [ + 73, + 160, + 148, + 167, + 29, + 57, + 59, + 54, + 218, + 164, + 165, + 145 + ], + "aad": [ + 23, + 115, + 9, + 207, + 201, + 19, + 227, + 245, + 192, + 147, + 232, + 177, + 49, + 155, + 168, + 24, + 38, + 212, + 60, + 229 + ], + "plaintext": [ + 124, + 190, + 121, + 130, + 211, + 101, + 165, + 93, + 20, + 124, + 149, + 69, + 131, + 249, + 118, + 10, + 9, + 148, + 138, + 183, + 62, + 187, + 225, + 178, + 193, + 214, + 158, + 213, + 142, + 9, + 42, + 52, + 115, + 146, + 25, + 44, + 254, + 139, + 206, + 24, + 202, + 67, + 238, + 25, + 175, + 118, + 82, + 51, + 27, + 217, + 44 + ], + "ciphertext": [ + 202, + 185, + 146, + 225, + 124, + 246, + 236, + 105, + 253, + 60, + 103, + 234, + 4, + 36, + 188, + 214, + 116, + 117, + 167, + 241, + 241, + 110, + 103, + 51, + 196, + 65, + 157, + 27, + 90, + 117, + 95, + 120, + 214, + 237, + 168, + 227, + 104, + 54, + 13, + 64, + 56, + 0, + 160, + 143, + 13, + 82, + 180, + 188, + 10, + 160, + 171 + ], + "tag": [ + 177, + 37, + 248, + 202, + 238, + 158, + 84, + 185, + 249, + 65, + 75, + 28, + 9, + 2, + 30, + 216 + ] + }, + { + "key": [ + 141, + 193, + 178, + 75, + 203, + 190, + 227, + 203, + 142, + 20, + 179, + 68, + 22, + 109, + 70, + 29, + 0, + 199, + 73, + 0, + 65, + 237, + 201, + 250, + 7, + 225, + 156, + 200, + 42, + 62, + 217, + 196 + ], + "nonce": [ + 49, + 118, + 138, + 209, + 140, + 151, + 27, + 24, + 141, + 148, + 112, + 25 + ], + "aad": [ + 235, + 54, + 115, + 182, + 69, + 96, + 204, + 167, + 189, + 167, + 106, + 29, + 231, + 174, + 16, + 20, + 238, + 26, + 202, + 238 + ], + "plaintext": [ + 132, + 228, + 247, + 157, + 187, + 114, + 9, + 203, + 175, + 112, + 228, + 254, + 254, + 19, + 124, + 73, + 71, + 134, + 200, + 153, + 96, + 39, + 131, + 233, + 192, + 52, + 41, + 105, + 120, + 215, + 240, + 197, + 113, + 247, + 234, + 157, + 128, + 237, + 12, + 196, + 114, + 49, + 36, + 135, + 45, + 115, + 38, + 137, + 3, + 0, + 193 + ], + "ciphertext": [ + 36, + 2, + 172, + 216, + 101, + 212, + 183, + 49, + 188, + 147, + 149, + 234, + 224, + 229, + 125, + 56, + 253, + 245, + 206, + 132, + 122, + 199, + 174, + 247, + 87, + 145, + 165, + 44, + 117, + 115, + 234, + 155, + 58, + 41, + 110, + 98, + 203, + 30, + 217, + 124, + 75, + 211, + 75, + 229, + 14, + 231, + 243, + 215, + 87, + 71, + 207 + ], + "tag": [ + 102, + 90, + 187, + 114, + 84, + 152, + 237, + 226, + 176, + 223, + 101, + 95, + 193, + 118, + 90, + 43 + ] + }, + { + "key": [ + 188, + 137, + 143, + 100, + 58, + 95, + 44, + 216, + 100, + 193, + 11, + 80, + 123, + 75, + 128, + 59, + 79, + 244, + 172, + 230, + 31, + 173, + 204, + 123, + 205, + 152, + 175, + 57, + 71, + 49, + 183, + 145 + ], + "nonce": [ + 204, + 68, + 125, + 131, + 192, + 166, + 115, + 74, + 121, + 119, + 140, + 100 + ], + "aad": [ + 233, + 50, + 189, + 46, + 14, + 108, + 85, + 13, + 19, + 111, + 114, + 94, + 20, + 197, + 61, + 39, + 255, + 178, + 15, + 106 + ], + "plaintext": [ + 18, + 78, + 185, + 99, + 205, + 181, + 111, + 164, + 156, + 112, + 169, + 177, + 170, + 104, + 36, + 69, + 197, + 80, + 101, + 242, + 104, + 89, + 241, + 209, + 110, + 239, + 124, + 254, + 73, + 21, + 135, + 83, + 62, + 237, + 215, + 226, + 61, + 234, + 189, + 223, + 197, + 85, + 12, + 47, + 166, + 160, + 139, + 23, + 130, + 38, + 153 + ], + "ciphertext": [ + 69, + 216, + 144, + 142, + 249, + 238, + 243, + 105, + 231, + 139, + 126, + 160, + 183, + 208, + 35, + 169, + 44, + 99, + 100, + 130, + 113, + 146, + 126, + 254, + 155, + 2, + 32, + 235, + 9, + 237, + 150, + 243, + 182, + 53, + 198, + 236, + 139, + 252, + 104, + 180, + 194, + 40, + 183, + 18, + 73, + 75, + 179, + 127, + 76, + 127, + 26 + ], + "tag": [ + 71, + 137, + 152, + 87, + 73, + 75, + 172, + 40, + 210, + 23, + 106, + 156, + 146, + 48, + 38, + 178 + ] + }, + { + "key": [ + 142, + 130, + 168, + 84, + 102, + 238, + 2, + 78, + 177, + 174, + 16, + 196, + 152, + 45, + 106, + 149, + 230, + 219, + 229, + 88, + 34, + 153, + 171, + 55, + 254, + 137, + 169, + 219, + 128, + 171, + 81, + 166 + ], + "nonce": [ + 4, + 207, + 212, + 137, + 225, + 142, + 235, + 122, + 74, + 138, + 179, + 107 + ], + "aad": [ + 123, + 181, + 75, + 26, + 110, + 208, + 202, + 56, + 114, + 104, + 161, + 70, + 67, + 12, + 11, + 250, + 38, + 2, + 168, + 253 + ], + "plaintext": [ + 58, + 162, + 228, + 234, + 237, + 24, + 196, + 96, + 39, + 21, + 174, + 119, + 55, + 158, + 144, + 131, + 112, + 138, + 249, + 249, + 180, + 144, + 49, + 50, + 77, + 65, + 171, + 202, + 97, + 68, + 3, + 25, + 200, + 200, + 230, + 219, + 204, + 32, + 0, + 106, + 130, + 91, + 18, + 206, + 208, + 11, + 34, + 134, + 132, + 138, + 148 + ], + "ciphertext": [ + 103, + 75, + 19, + 145, + 147, + 112, + 116, + 100, + 36, + 8, + 238, + 174, + 155, + 116, + 140, + 166, + 41, + 218, + 159, + 208, + 2, + 129, + 130, + 79, + 90, + 16, + 143, + 96, + 120, + 238, + 120, + 249, + 135, + 73, + 57, + 43, + 182, + 226, + 155, + 83, + 229, + 62, + 75, + 17, + 115, + 154, + 197, + 58, + 142, + 101, + 59 + ], + "tag": [ + 227, + 32, + 168, + 115, + 169, + 194, + 232, + 239, + 69, + 86, + 152, + 195, + 126, + 165, + 154, + 109 + ] + }, + { + "key": [ + 241, + 242, + 197, + 80, + 62, + 191, + 53, + 172, + 19, + 115, + 194, + 158, + 35, + 5, + 233, + 99, + 248, + 159, + 110, + 208, + 21, + 161, + 129, + 183, + 15, + 181, + 73, + 66, + 152, + 5, + 213, + 217 + ], + "nonce": [ + 47, + 181, + 198, + 162, + 79, + 64, + 104, + 114, + 117, + 93, + 176, + 92 + ], + "aad": [ + 146, + 193, + 243, + 72, + 154, + 237, + 144, + 174, + 218, + 251, + 85, + 86, + 42, + 52, + 179, + 244, + 190, + 41, + 225, + 1 + ], + "plaintext": [ + 180, + 162, + 128, + 145, + 152, + 3, + 92, + 39, + 118, + 55, + 187, + 28, + 41, + 39, + 251, + 92, + 96, + 180, + 158, + 249, + 8, + 124, + 128, + 0, + 18, + 216, + 102, + 61, + 153, + 121, + 131, + 252, + 183, + 141, + 81, + 160, + 84, + 17, + 74, + 36, + 225, + 225, + 181, + 33, + 75, + 88, + 231, + 222, + 228, + 113, + 149 + ], + "ciphertext": [ + 240, + 81, + 163, + 169, + 104, + 39, + 138, + 70, + 99, + 11, + 40, + 148, + 160, + 211, + 134, + 193, + 143, + 160, + 52, + 150, + 13, + 141, + 221, + 20, + 232, + 142, + 16, + 113, + 175, + 187, + 202, + 91, + 175, + 2, + 150, + 124, + 34, + 112, + 17, + 123, + 79, + 178, + 189, + 76, + 253, + 3, + 33, + 116, + 80, + 95, + 153 + ], + "tag": [ + 111, + 29, + 181, + 41, + 54, + 96, + 182, + 144, + 79, + 127, + 0, + 142, + 64, + 155, + 220, + 6 + ] + }, + { + "key": [ + 240, + 51, + 141, + 38, + 215, + 75, + 209, + 118, + 141, + 165, + 187, + 121, + 197, + 159, + 171, + 43, + 74, + 190, + 25, + 102, + 50, + 64, + 72, + 121, + 12, + 68, + 188, + 152, + 166, + 179, + 75, + 108 + ], + "nonce": [ + 200, + 38, + 158, + 68, + 6, + 250, + 11, + 225, + 207, + 5, + 123, + 47 + ], + "aad": [ + 19, + 251, + 14, + 220, + 186, + 9, + 92, + 239, + 156, + 67, + 67, + 160, + 98, + 159, + 213, + 2, + 15, + 3, + 114, + 157 + ], + "plaintext": [ + 50, + 60, + 55, + 62, + 77, + 133, + 161, + 253, + 33, + 243, + 135, + 253, + 216, + 199, + 230, + 174, + 235, + 213, + 170, + 232, + 147, + 215, + 175, + 40, + 108, + 178, + 20, + 96, + 12, + 186, + 139, + 158, + 176, + 109, + 240, + 133, + 162, + 220, + 90, + 237, + 135, + 2, + 89, + 247, + 243, + 204, + 129, + 211, + 235, + 83, + 189 + ], + "ciphertext": [ + 8, + 87, + 43, + 156, + 249, + 188, + 253, + 33, + 212, + 64, + 58, + 18, + 24, + 217, + 68, + 118, + 185, + 238, + 140, + 59, + 148, + 197, + 102, + 37, + 194, + 28, + 202, + 244, + 192, + 239, + 163, + 76, + 242, + 42, + 83, + 35, + 137, + 33, + 7, + 147, + 105, + 156, + 157, + 225, + 171, + 20, + 248, + 196, + 197, + 41, + 40 + ], + "tag": [ + 41, + 150, + 140, + 159, + 182, + 16, + 148, + 12, + 238, + 159, + 213, + 178, + 247, + 200, + 186, + 33 + ] + }, + { + "key": [ + 166, + 118, + 72, + 40, + 91, + 101, + 185, + 25, + 96, + 96, + 170, + 160, + 42, + 242, + 121, + 23, + 1, + 100, + 53, + 62, + 56, + 251, + 119, + 195, + 150, + 140, + 64, + 60, + 250, + 154, + 205, + 200 + ], + "nonce": [ + 8, + 34, + 214, + 179, + 233, + 30, + 204, + 183, + 225, + 66, + 69, + 253 + ], + "aad": [ + 13, + 154, + 90, + 247, + 172, + 39, + 67, + 141, + 146, + 83, + 77, + 151, + 255, + 67, + 120, + 39, + 71, + 144, + 229, + 159 + ], + "plaintext": [ + 181, + 210, + 113, + 118, + 140, + 18, + 204, + 171, + 248, + 158, + 178, + 213, + 140, + 189, + 232, + 64, + 194, + 109, + 28, + 155, + 54, + 146, + 88, + 31, + 144, + 200, + 176, + 215, + 178, + 207, + 243, + 26, + 233, + 25, + 45, + 40, + 79, + 84, + 72, + 222, + 125, + 146, + 74, + 123, + 8, + 241, + 21, + 237, + 174, + 117, + 170 + ], + "ciphertext": [ + 181, + 144, + 65, + 238, + 215, + 171, + 194, + 255, + 80, + 125, + 25, + 50, + 181, + 197, + 90, + 197, + 39, + 40, + 229, + 172, + 102, + 72, + 220, + 199, + 75, + 56, + 135, + 13, + 182, + 24, + 27, + 25, + 137, + 249, + 90, + 1, + 68, + 240, + 219, + 54, + 142, + 197, + 4, + 20, + 207, + 218, + 11, + 151, + 113, + 65, + 227 + ], + "tag": [ + 29, + 18, + 206, + 137, + 225, + 38, + 29, + 115, + 71, + 15, + 58, + 227, + 106, + 184, + 114, + 136 + ] + }, + { + "key": [ + 81, + 22, + 43, + 36, + 53, + 243, + 207, + 67, + 71, + 31, + 76, + 192, + 255, + 172, + 152, + 180, + 56, + 80, + 30, + 233, + 184, + 135, + 132, + 58, + 102, + 233, + 149, + 28, + 163, + 91, + 135, + 103 + ], + "nonce": [ + 220, + 185, + 2, + 234, + 168, + 55, + 237, + 34, + 191, + 95, + 166, + 54 + ], + "aad": [ + 77, + 69, + 153, + 5, + 255, + 137, + 174, + 208, + 125, + 205, + 164, + 58, + 61, + 25, + 26, + 61, + 169, + 48, + 159, + 170 + ], + "plaintext": [ + 62, + 223, + 67, + 53, + 143, + 81, + 9, + 164, + 223, + 180, + 160, + 41, + 135, + 23, + 10, + 103, + 205, + 209, + 112, + 246, + 2, + 143, + 119, + 8, + 189, + 215, + 114, + 111, + 71, + 107, + 136, + 43, + 150, + 64, + 39, + 15, + 34, + 112, + 247, + 186, + 191, + 163, + 132, + 24, + 28, + 142, + 88, + 193, + 93, + 4, + 196 + ], + "ciphertext": [ + 4, + 106, + 35, + 19, + 211, + 108, + 188, + 67, + 182, + 208, + 120, + 126, + 94, + 243, + 125, + 21, + 48, + 144, + 163, + 29, + 15, + 102, + 86, + 0, + 64, + 52, + 190, + 114, + 185, + 176, + 122, + 206, + 58, + 138, + 190, + 134, + 20, + 54, + 34, + 130, + 216, + 125, + 164, + 12, + 41, + 198, + 10, + 26, + 159, + 92, + 64 + ], + "tag": [ + 199, + 65, + 11, + 92, + 185, + 77, + 40, + 119, + 193, + 137, + 152, + 55, + 145, + 206, + 232, + 46 + ] + }, + { + "key": [ + 47, + 162, + 190, + 177, + 205, + 226, + 34, + 111, + 40, + 251, + 66, + 165, + 251, + 10, + 243, + 252, + 88, + 251, + 183, + 107, + 241, + 74, + 164, + 54, + 230, + 83, + 93, + 70, + 100, + 86, + 160, + 244 + ], + "nonce": [ + 80, + 25, + 5, + 20, + 163, + 116, + 11, + 60, + 11, + 29, + 245, + 118 + ], + "aad": [ + 37, + 20, + 41, + 40, + 193, + 174, + 156, + 123, + 133, + 3, + 9, + 224, + 125, + 243, + 89, + 56, + 157, + 181, + 57, + 252 + ], + "plaintext": [ + 165, + 224, + 180, + 131, + 125, + 252, + 162, + 99, + 186, + 40, + 106, + 191, + 121, + 64, + 182, + 231, + 15, + 171, + 181, + 93, + 141, + 238, + 80, + 40, + 97, + 124, + 17, + 144, + 251, + 211, + 39, + 247, + 155, + 121, + 210, + 243, + 77, + 182, + 7, + 106, + 176, + 124, + 236, + 255, + 113, + 20, + 177, + 92, + 160, + 42, + 51 + ], + "ciphertext": [ + 133, + 15, + 210, + 43, + 208, + 137, + 123, + 152, + 206, + 64, + 188, + 108, + 19, + 69, + 169, + 213, + 154, + 191, + 121, + 107, + 27, + 140, + 52, + 238, + 139, + 55, + 126, + 84, + 238, + 125, + 89, + 222, + 192, + 92, + 2, + 46, + 202, + 233, + 111, + 253, + 250, + 19, + 17, + 189, + 212, + 231, + 169, + 211, + 90, + 172, + 71 + ], + "tag": [ + 75, + 90, + 184, + 155, + 79, + 98, + 124, + 163, + 45, + 18, + 161, + 121, + 28, + 40, + 104, + 112 + ] + }, + { + "key": [ + 169, + 42, + 121, + 124, + 226, + 178, + 243, + 130, + 3, + 11, + 119, + 161, + 171, + 233, + 76, + 128, + 118, + 238, + 232, + 141, + 226, + 220, + 73, + 41, + 53, + 11, + 36, + 77, + 189, + 173, + 221, + 48 + ], + "nonce": [ + 113, + 111, + 87, + 116, + 1, + 167, + 137, + 60, + 66, + 201, + 23, + 16 + ], + "aad": [ + 134, + 66, + 104, + 31, + 24, + 57, + 184, + 137, + 144, + 194, + 169, + 57, + 240, + 12, + 155, + 144, + 118, + 109, + 173, + 172 + ], + "plaintext": [ + 157, + 38, + 255, + 121, + 168, + 151, + 32, + 250, + 182, + 228, + 205, + 168, + 88, + 135, + 227, + 192, + 195, + 248, + 106, + 70, + 112, + 208, + 101, + 200, + 234, + 104, + 4, + 43, + 111, + 159, + 22, + 221, + 44, + 91, + 49, + 172, + 179, + 99, + 49, + 245, + 177, + 229, + 15, + 8, + 196, + 146, + 220, + 18, + 238, + 189, + 158 + ], + "ciphertext": [ + 48, + 128, + 188, + 243, + 96, + 76, + 248, + 31, + 95, + 44, + 110, + 220, + 128, + 223, + 229, + 216, + 119, + 22, + 138, + 153, + 3, + 89, + 138, + 112, + 10, + 11, + 186, + 225, + 136, + 250, + 220, + 122, + 139, + 118, + 160, + 75, + 64, + 64, + 15, + 146, + 82, + 215, + 249, + 67, + 127, + 168, + 240, + 36, + 163, + 189, + 235 + ], + "tag": [ + 143, + 197, + 111, + 107, + 244, + 142, + 251, + 0, + 71, + 104, + 134, + 178, + 160, + 62, + 203, + 137 + ] + }, + { + "key": [ + 137, + 208, + 114, + 62, + 90, + 8, + 116, + 86, + 183, + 183, + 9, + 184, + 178, + 27, + 227, + 128, + 180, + 99, + 186, + 61, + 201, + 183, + 145, + 112, + 233, + 148, + 117, + 38, + 121, + 143, + 233, + 28 + ], + "nonce": [ + 104, + 226, + 243, + 7, + 183, + 212, + 157, + 77, + 156, + 4, + 23, + 85 + ], + "aad": [ + 179, + 72, + 5, + 179, + 7, + 3, + 166, + 43, + 109, + 55, + 201, + 63, + 36, + 67, + 225, + 163, + 49, + 84, + 181, + 251 + ], + "plaintext": [ + 127, + 226, + 175, + 183, + 16, + 232, + 253, + 73, + 204, + 161, + 194, + 186, + 143, + 208, + 129, + 69, + 148, + 251, + 164, + 214, + 103, + 1, + 118, + 48, + 225, + 112, + 168, + 163, + 121, + 250, + 88, + 55, + 191, + 55, + 12, + 161, + 205, + 76, + 152, + 189, + 140, + 79, + 19, + 235, + 112, + 104, + 255, + 167, + 26, + 176, + 124 + ], + "ciphertext": [ + 184, + 65, + 1, + 39, + 82, + 187, + 241, + 223, + 167, + 181, + 147, + 102, + 219, + 243, + 83, + 191, + 152, + 182, + 31, + 242, + 230, + 231, + 161, + 61, + 100, + 217, + 220, + 181, + 139, + 119, + 16, + 3, + 200, + 132, + 42, + 192, + 2, + 170, + 193, + 250, + 140, + 160, + 10, + 33, + 234, + 241, + 1, + 171, + 68, + 243, + 128 + ], + "tag": [ + 115, + 169, + 62, + 39, + 34, + 219, + 99, + 194, + 187, + 244, + 112, + 213, + 25, + 59, + 34, + 48 + ] + }, + { + "key": [ + 50, + 154, + 110, + 148, + 177, + 204, + 230, + 147, + 228, + 69, + 105, + 70, + 80, + 214, + 43, + 140, + 44, + 154, + 176, + 58, + 9, + 230, + 212, + 236, + 160, + 92, + 72, + 41, + 30, + 87, + 107, + 137 + ], + "nonce": [ + 120, + 244, + 113, + 188, + 50, + 248, + 99, + 122, + 33, + 62, + 135, + 172 + ], + "aad": [ + 192, + 12, + 70, + 85, + 36, + 226, + 226, + 248, + 165, + 92, + 7, + 147, + 237, + 154, + 248, + 81, + 190, + 69, + 167, + 14 + ], + "plaintext": [ + 101, + 38, + 77, + 117, + 225, + 161, + 118, + 167, + 233, + 102, + 229, + 145, + 9, + 205, + 7, + 74, + 197, + 213, + 71, + 64, + 235, + 12, + 88, + 8, + 74, + 240, + 35, + 229, + 89, + 158, + 182, + 17, + 132, + 97, + 153, + 87, + 157, + 149, + 186, + 148, + 182, + 210, + 94, + 228, + 217, + 7, + 75, + 151, + 20, + 242, + 49 + ], + "ciphertext": [ + 150, + 77, + 102, + 93, + 30, + 60, + 16, + 24, + 223, + 216, + 131, + 226, + 23, + 207, + 228, + 200, + 86, + 204, + 132, + 79, + 118, + 68, + 181, + 59, + 182, + 143, + 190, + 102, + 248, + 84, + 31, + 164, + 58, + 197, + 78, + 146, + 162, + 177, + 148, + 214, + 216, + 146, + 159, + 224, + 49, + 233, + 75, + 62, + 112, + 236, + 160 + ], + "tag": [ + 253, + 81, + 19, + 133, + 113, + 18, + 54, + 242, + 233, + 158, + 109, + 165, + 4, + 32, + 7, + 183 + ] + }, + { + "key": [ + 70, + 59, + 65, + 41, + 17, + 118, + 125, + 87, + 160, + 179, + 57, + 105, + 230, + 116, + 255, + 231, + 132, + 93, + 49, + 59, + 136, + 198, + 254, + 49, + 47, + 61, + 114, + 75, + 230, + 142, + 31, + 202 + ], + "nonce": [ + 97, + 28, + 230, + 249, + 166, + 136, + 7, + 80, + 222, + 125, + 166, + 203 + ], + "aad": [ + 10, + 104, + 47, + 188, + 97, + 146, + 225, + 180, + 122, + 94, + 8, + 104, + 120, + 127, + 253, + 175, + 229, + 165, + 12, + 234, + 211, + 87, + 88, + 73, + 153, + 12, + 221, + 46, + 169, + 179, + 89, + 119, + 73, + 64, + 62, + 251, + 74, + 86, + 104, + 79, + 12, + 107, + 222, + 53, + 45, + 74, + 238, + 197 + ], + "plaintext": [ + 231, + 209, + 220, + 246, + 104, + 226, + 135, + 104, + 97, + 148, + 14, + 1, + 47, + 229, + 42, + 152, + 218, + 203, + 215, + 138, + 182, + 60, + 8, + 132, + 44, + 201, + 128, + 30, + 165, + 129, + 104, + 42, + 213, + 74, + 240, + 195, + 77, + 13, + 127, + 111, + 89, + 232, + 238, + 11, + 244, + 144, + 14, + 15, + 216, + 80, + 66 + ], + "ciphertext": [ + 136, + 134, + 225, + 150, + 1, + 12, + 179, + 132, + 157, + 156, + 26, + 24, + 42, + 190, + 30, + 234, + 176, + 165, + 243, + 202, + 66, + 60, + 54, + 105, + 164, + 168, + 112, + 60, + 15, + 20, + 110, + 142, + 149, + 111, + 177, + 34, + 224, + 215, + 33, + 184, + 105, + 210, + 182, + 252, + 212, + 33, + 109, + 125, + 77, + 55, + 88 + ], + "tag": [ + 36, + 105, + 206, + 205, + 112, + 253, + 152, + 254, + 201, + 38, + 79, + 113, + 223, + 26, + 238, + 154 + ] + }, + { + "key": [ + 85, + 249, + 23, + 26, + 3, + 194, + 30, + 9, + 227, + 165, + 253, + 119, + 30, + 86, + 191, + 251, + 119, + 94, + 187, + 25, + 3, + 25, + 243, + 220, + 33, + 76, + 75, + 25, + 247, + 46, + 84, + 130 + ], + "nonce": [ + 20, + 243, + 191, + 149, + 160, + 142, + 143, + 82, + 235, + 70, + 251, + 249 + ], + "aad": [ + 186, + 193, + 221, + 239, + 209, + 17, + 212, + 113, + 231, + 95, + 14, + 251, + 15, + 129, + 39, + 180, + 218, + 146, + 62, + 204, + 120, + 138, + 92, + 145, + 227, + 226, + 246, + 94, + 41, + 67, + 228, + 202, + 244, + 47, + 84, + 137, + 102, + 4, + 175, + 25, + 237, + 11, + 77, + 134, + 151, + 212, + 90, + 185 + ], + "plaintext": [ + 175, + 107, + 23, + 253, + 103, + 188, + 17, + 115, + 176, + 99, + 252, + 111, + 9, + 65, + 72, + 60, + 238, + 156, + 187, + 187, + 237, + 58, + 77, + 207, + 245, + 90, + 116, + 176, + 201, + 83, + 91, + 151, + 126, + 250, + 100, + 14, + 91, + 26, + 48, + 250, + 168, + 89, + 253, + 61, + 170, + 141, + 215, + 128, + 204, + 148, + 160 + ], + "ciphertext": [ + 58, + 232, + 103, + 128, + 137, + 82, + 35, + 113, + 254, + 75, + 212, + 218, + 153, + 255, + 216, + 58, + 50, + 152, + 142, + 7, + 40, + 170, + 58, + 73, + 112, + 222, + 209, + 254, + 115, + 188, + 48, + 194, + 235, + 31, + 226, + 76, + 15, + 245, + 171, + 84, + 154, + 199, + 229, + 103, + 215, + 3, + 102, + 40, + 253, + 113, + 141 + ], + "tag": [ + 207, + 89, + 96, + 62, + 5, + 244, + 237, + 29, + 45, + 160, + 78, + 25, + 57, + 155, + 133, + 18 + ] + }, + { + "key": [ + 84, + 96, + 29, + 21, + 56, + 229, + 240, + 77, + 195, + 254, + 149, + 228, + 131, + 228, + 13, + 236, + 10, + 170, + 88, + 55, + 93, + 200, + 104, + 218, + 22, + 124, + 154, + 89, + 158, + 211, + 69, + 217 + ], + "nonce": [ + 197, + 21, + 8, + 114, + 228, + 92, + 52, + 28, + 43, + 153, + 198, + 154 + ], + "aad": [ + 147, + 205, + 126, + 232, + 100, + 138, + 100, + 197, + 157, + 84, + 205, + 172, + 69, + 91, + 5, + 255, + 223, + 194, + 239, + 254, + 139, + 25, + 181, + 11, + 171, + 216, + 193, + 168, + 194, + 31, + 93, + 200, + 220, + 96, + 80, + 226, + 52, + 127, + 76, + 210, + 135, + 1, + 89, + 75, + 159, + 141, + 77, + 229 + ], + "plaintext": [ + 174, + 135, + 192, + 140, + 118, + 16, + 161, + 37, + 231, + 170, + 111, + 147, + 250, + 192, + 248, + 4, + 114, + 83, + 11, + 44, + 228, + 215, + 25, + 79, + 95, + 76, + 184, + 172, + 2, + 83, + 35, + 198, + 196, + 58, + 128, + 103, + 136, + 239, + 80, + 197, + 2, + 135, + 100, + 236, + 50, + 242, + 131, + 144, + 5, + 200, + 19 + ], + "ciphertext": [ + 213, + 240, + 5, + 220, + 103, + 189, + 201, + 115, + 132, + 7, + 206, + 36, + 1, + 151, + 127, + 89, + 201, + 200, + 53, + 32, + 226, + 98, + 208, + 200, + 219, + 127, + 228, + 122, + 224, + 234, + 218, + 48, + 214, + 116, + 105, + 79, + 0, + 142, + 34, + 47, + 151, + 51, + 166, + 230, + 61, + 129, + 73, + 158, + 36, + 117, + 103 + ], + "tag": [ + 52, + 112, + 21, + 81, + 68, + 199, + 73, + 41, + 152, + 1, + 52, + 219, + 105, + 149, + 221, + 136 + ] + }, + { + "key": [ + 233, + 102, + 196, + 112, + 203, + 236, + 200, + 25, + 38, + 6, + 64, + 213, + 64, + 76, + 132, + 56, + 46, + 110, + 100, + 157, + 169, + 109, + 41, + 202, + 210, + 212, + 65, + 46, + 103, + 30, + 216, + 2 + ], + "nonce": [ + 179, + 169, + 45, + 111, + 73, + 254, + 44, + 185, + 193, + 68, + 211, + 57 + ], + "aad": [ + 223, + 166, + 42, + 58, + 75, + 91, + 58, + 246, + 119, + 12, + 253, + 60, + 239, + 59, + 187, + 76, + 206, + 63, + 100, + 146, + 87, + 130, + 169, + 168, + 166, + 225, + 95, + 227, + 116, + 77, + 143, + 147, + 16, + 64, + 13, + 208, + 78, + 141, + 121, + 102, + 192, + 56, + 80, + 83, + 158, + 68, + 10, + 165 + ], + "plaintext": [ + 122, + 223, + 111, + 203, + 65, + 213, + 155, + 141, + 43, + 102, + 48, + 16, + 195, + 212, + 207, + 95, + 95, + 11, + 149, + 207, + 117, + 79, + 118, + 248, + 98, + 108, + 68, + 40, + 70, + 126, + 92, + 102, + 132, + 231, + 126, + 120, + 87, + 177, + 204, + 117, + 87, + 98, + 233, + 234, + 145, + 23, + 227, + 187, + 7, + 112, + 64 + ], + "ciphertext": [ + 95, + 91, + 9, + 72, + 110, + 108, + 210, + 168, + 84, + 229, + 98, + 43, + 73, + 136, + 226, + 64, + 143, + 221, + 172, + 164, + 44, + 33, + 217, + 70, + 197, + 205, + 120, + 159, + 229, + 161, + 48, + 110, + 243, + 60, + 140, + 212, + 68, + 103, + 173, + 122, + 164, + 200, + 21, + 43, + 206, + 101, + 106, + 32, + 54, + 114, + 132 + ], + "tag": [ + 43, + 56, + 129, + 9, + 175, + 218, + 218, + 100, + 115, + 67, + 82, + 48, + 215, + 71, + 180, + 235 + ] + }, + { + "key": [ + 74, + 138, + 18, + 192, + 87, + 94, + 198, + 90, + 225, + 197, + 120, + 77, + 40, + 41, + 188, + 123, + 4, + 129, + 142, + 176, + 11, + 212, + 201, + 10, + 13, + 3, + 46, + 162, + 129, + 7, + 110, + 39 + ], + "nonce": [ + 149, + 159, + 17, + 59, + 112, + 83, + 151, + 251, + 115, + 128, + 24, + 176 + ], + "aad": [ + 173, + 184, + 188, + 150, + 20, + 42, + 16, + 37, + 18, + 45, + 194, + 47, + 130, + 105, + 87, + 25, + 122, + 243, + 61, + 205, + 207, + 107, + 122, + 181, + 107, + 193, + 165, + 225, + 126, + 133, + 52, + 228, + 139, + 141, + 175, + 104, + 95, + 175, + 149, + 67, + 187, + 52, + 54, + 20, + 189, + 246, + 115, + 127 + ], + "plaintext": [ + 12, + 85, + 113, + 25, + 85, + 134, + 228, + 252, + 112, + 150, + 251, + 134, + 207, + 205, + 102, + 132, + 8, + 20, + 70, + 243, + 215, + 173, + 195, + 58, + 137, + 127, + 3, + 172, + 79, + 246, + 195, + 204, + 32, + 25, + 182, + 123, + 211, + 24, + 76, + 134, + 7, + 7, + 100, + 246, + 222, + 170, + 138, + 16, + 208, + 216, + 31 + ], + "ciphertext": [ + 132, + 33, + 45, + 89, + 145, + 35, + 29, + 53, + 196, + 232, + 98, + 17, + 99, + 229, + 179, + 112, + 160, + 16, + 90, + 5, + 133, + 104, + 102, + 231, + 77, + 247, + 44, + 8, + 8, + 192, + 98, + 152, + 21, + 112, + 211, + 45, + 39, + 78, + 167, + 50, + 250, + 77, + 41, + 249, + 207, + 167, + 131, + 156, + 173, + 190, + 106 + ], + "tag": [ + 57, + 206, + 227, + 184, + 250, + 11, + 249, + 38, + 5, + 102, + 108, + 205, + 158, + 177, + 152, + 64 + ] + }, + { + "key": [ + 97, + 151, + 164, + 250, + 124, + 252, + 237, + 239, + 242, + 35, + 246, + 158, + 166, + 139, + 77, + 223, + 84, + 182, + 131, + 53, + 12, + 32, + 135, + 91, + 227, + 83, + 7, + 126, + 155, + 188, + 227, + 70 + ], + "nonce": [ + 26, + 105, + 236, + 171, + 212, + 44, + 83, + 192, + 236, + 100, + 252, + 208 + ], + "aad": [ + 178, + 10, + 124, + 165, + 181, + 182, + 3, + 246, + 97, + 88, + 126, + 1, + 247, + 239, + 23, + 24, + 35, + 239, + 70, + 60, + 24, + 125, + 237, + 119, + 163, + 214, + 22, + 64, + 12, + 193, + 210, + 176, + 182, + 136, + 172, + 158, + 146, + 116, + 152, + 52, + 21, + 96, + 203, + 200, + 235, + 154, + 65, + 152 + ], + "plaintext": [ + 64, + 164, + 135, + 180, + 218, + 248, + 102, + 194, + 15, + 60, + 73, + 17, + 160, + 88, + 103, + 9, + 195, + 52, + 74, + 169, + 136, + 220, + 156, + 70, + 75, + 207, + 54, + 204, + 78, + 61, + 146, + 112, + 30, + 97, + 30, + 96, + 207, + 105, + 243, + 237, + 191, + 118, + 205, + 39, + 255, + 107, + 169, + 53, + 2, + 109, + 127 + ], + "ciphertext": [ + 6, + 66, + 15, + 160, + 56, + 238, + 98, + 219, + 48, + 204, + 5, + 191, + 227, + 76, + 141, + 44, + 57, + 169, + 212, + 57, + 101, + 57, + 7, + 197, + 18, + 237, + 96, + 101, + 17, + 146, + 31, + 231, + 97, + 16, + 145, + 58, + 91, + 251, + 107, + 108, + 123, + 35, + 215, + 248, + 136, + 63, + 90, + 182, + 95, + 75, + 20 + ], + "tag": [ + 77, + 48, + 151, + 201, + 145, + 144, + 2, + 205, + 29, + 168, + 63, + 41, + 130, + 3, + 18, + 237 + ] + }, + { + "key": [ + 201, + 219, + 225, + 133, + 2, + 62, + 202, + 167, + 139, + 233, + 191, + 172, + 27, + 145, + 185, + 218, + 107, + 215, + 193, + 19, + 73, + 254, + 182, + 158, + 107, + 11, + 232, + 58, + 131, + 142, + 119, + 178 + ], + "nonce": [ + 137, + 64, + 250, + 124, + 106, + 253, + 63, + 122, + 9, + 236, + 147, + 182 + ], + "aad": [ + 241, + 123, + 211, + 87, + 96, + 131, + 101, + 230, + 107, + 152, + 228, + 145, + 145, + 205, + 194, + 163, + 129, + 59, + 186, + 90, + 27, + 121, + 136, + 170, + 138, + 170, + 170, + 212, + 184, + 109, + 14, + 244, + 226, + 105, + 140, + 173, + 121, + 157, + 99, + 252, + 210, + 165, + 232, + 124, + 14, + 62, + 146, + 154 + ], + "plaintext": [ + 7, + 91, + 224, + 214, + 18, + 115, + 230, + 151, + 89, + 120, + 208, + 184, + 139, + 63, + 163, + 143, + 195, + 152, + 212, + 208, + 242, + 42, + 52, + 42, + 138, + 250, + 85, + 98, + 175, + 14, + 124, + 143, + 165, + 72, + 240, + 216, + 250, + 236, + 137, + 138, + 32, + 201, + 126, + 133, + 23, + 84, + 153, + 44, + 30, + 212, + 163 + ], + "ciphertext": [ + 97, + 92, + 16, + 151, + 213, + 119, + 54, + 58, + 119, + 191, + 199, + 221, + 87, + 23, + 154, + 203, + 104, + 22, + 110, + 120, + 2, + 27, + 51, + 151, + 215, + 2, + 156, + 227, + 60, + 188, + 132, + 143, + 3, + 107, + 156, + 7, + 152, + 158, + 235, + 159, + 66, + 174, + 174, + 235, + 232, + 84, + 47, + 16, + 59, + 29, + 50 + ], + "tag": [ + 162, + 42, + 178, + 95, + 216, + 166, + 18, + 116, + 105, + 232, + 206, + 159, + 246, + 134, + 213, + 117 + ] + }, + { + "key": [ + 230, + 205, + 207, + 73, + 122, + 110, + 17, + 144, + 9, + 191, + 67, + 172, + 24, + 61, + 45, + 212, + 212, + 233, + 103, + 150, + 78, + 249, + 40, + 17, + 246, + 158, + 177, + 141, + 146, + 146, + 51, + 5 + ], + "nonce": [ + 62, + 136, + 69, + 154, + 118, + 225, + 220, + 200, + 144, + 120, + 130, + 151 + ], + "aad": [ + 163, + 89, + 248, + 110, + 201, + 24, + 83, + 125, + 128, + 168, + 77, + 167, + 182, + 107, + 202, + 112, + 12, + 31, + 249, + 236, + 127, + 134, + 149, + 163, + 8, + 8, + 212, + 132, + 218, + 33, + 141, + 21, + 174, + 137, + 197, + 249, + 67, + 231, + 23, + 120, + 68, + 81, + 48, + 25, + 31, + 119, + 144, + 1 + ], + "plaintext": [ + 114, + 163, + 223, + 181, + 85, + 186, + 0, + 41, + 252, + 61, + 28, + 133, + 184, + 54, + 247, + 97, + 53, + 189, + 24, + 88, + 24, + 158, + 253, + 222, + 45, + 178, + 144, + 69, + 242, + 194, + 110, + 106, + 101, + 98, + 125, + 129, + 160, + 184, + 92, + 164, + 46, + 130, + 105, + 212, + 50, + 164, + 17, + 84, + 233, + 41, + 172 + ], + "ciphertext": [ + 154, + 227, + 248, + 204, + 174, + 11, + 181, + 120, + 155, + 17, + 5, + 17, + 135, + 96, + 196, + 6, + 228, + 17, + 117, + 167, + 102, + 18, + 67, + 92, + 176, + 200, + 190, + 34, + 94, + 166, + 179, + 104, + 201, + 208, + 140, + 157, + 154, + 36, + 181, + 18, + 209, + 69, + 142, + 148, + 175, + 121, + 227, + 6, + 10, + 182, + 158 + ], + "tag": [ + 172, + 59, + 188, + 143, + 214, + 167, + 9, + 125, + 246, + 242, + 152, + 65, + 28, + 35, + 227, + 133 + ] + }, + { + "key": [ + 222, + 85, + 49, + 181, + 8, + 136, + 182, + 29, + 99, + 175, + 34, + 16, + 238, + 35, + 244, + 109, + 145, + 165, + 230, + 3, + 18, + 189, + 87, + 133, + 132, + 175, + 88, + 107, + 242, + 46, + 167, + 86 + ], + "nonce": [ + 15, + 222, + 134, + 137, + 176, + 52, + 139, + 188, + 250, + 168, + 159, + 236 + ], + "aad": [ + 34, + 219, + 151, + 205, + 95, + 53, + 159, + 18, + 174, + 198, + 108, + 81, + 199, + 218, + 121, + 186, + 98, + 157, + 180, + 200, + 199, + 229, + 80, + 27, + 226, + 236, + 30, + 76, + 195, + 243, + 148, + 75, + 110, + 48, + 87, + 208, + 147, + 188, + 104, + 183, + 53, + 181, + 21, + 105, + 80, + 249, + 24, + 4 + ], + "plaintext": [ + 128, + 98, + 30, + 84, + 238, + 241, + 201, + 42, + 251, + 31, + 100, + 237, + 134, + 14, + 57, + 49, + 30, + 234, + 126, + 44, + 202, + 111, + 86, + 36, + 0, + 140, + 29, + 46, + 88, + 29, + 113, + 18, + 183, + 238, + 11, + 85, + 159, + 195, + 219, + 87, + 91, + 123, + 124, + 66, + 238, + 79, + 42, + 32, + 68, + 45, + 192 + ], + "ciphertext": [ + 147, + 48, + 24, + 65, + 154, + 50, + 183, + 191, + 101, + 249, + 119, + 124, + 68, + 136, + 154, + 68, + 179, + 45, + 97, + 206, + 221, + 187, + 70, + 131, + 147, + 102, + 206, + 44, + 162, + 255, + 235, + 24, + 51, + 244, + 101, + 89, + 229, + 156, + 147, + 187, + 7, + 246, + 34, + 217, + 99, + 63, + 19, + 147, + 44, + 247, + 241 + ], + "tag": [ + 37, + 2, + 58, + 78, + 233, + 189, + 191, + 82, + 92, + 254, + 248, + 136, + 226, + 72, + 15, + 134 + ] + }, + { + "key": [ + 188, + 12, + 99, + 104, + 169, + 187, + 38, + 34, + 246, + 213, + 186, + 18, + 222, + 88, + 31, + 0, + 51, + 54, + 194, + 152, + 173, + 172, + 52, + 73, + 155, + 242, + 107, + 17, + 230, + 48, + 248, + 145 + ], + "nonce": [ + 42, + 168, + 243, + 11, + 86, + 124, + 241, + 237, + 216, + 24, + 228, + 45 + ], + "aad": [ + 14, + 40, + 235, + 248, + 126, + 183, + 87, + 232, + 48, + 49, + 251, + 131, + 111, + 123, + 4, + 154, + 70, + 189, + 116, + 11, + 10, + 57, + 201, + 183, + 152, + 210, + 64, + 126, + 17, + 80, + 218, + 134, + 223, + 232, + 65, + 33, + 199, + 201, + 132, + 73, + 85, + 148, + 83, + 173, + 117, + 88, + 231, + 121 + ], + "plaintext": [ + 29, + 204, + 26, + 49, + 103, + 251, + 165, + 92, + 0, + 211, + 56, + 62, + 38, + 211, + 134, + 234, + 160, + 68, + 145, + 84, + 89, + 153, + 146, + 218, + 127, + 127, + 101, + 152, + 244, + 27, + 62, + 184, + 228, + 208, + 169, + 20, + 61, + 252, + 171, + 150, + 63, + 92, + 57, + 10, + 106, + 226, + 1, + 15, + 188, + 246, + 236 + ], + "ciphertext": [ + 120, + 208, + 10, + 110, + 51, + 2, + 54, + 152, + 23, + 185, + 207, + 31, + 36, + 234, + 19, + 196, + 23, + 81, + 56, + 46, + 63, + 234, + 116, + 64, + 61, + 9, + 71, + 55, + 227, + 47, + 181, + 7, + 24, + 76, + 254, + 188, + 228, + 141, + 16, + 180, + 206, + 141, + 177, + 46, + 249, + 97, + 228, + 223, + 44, + 142, + 149 + ], + "tag": [ + 192, + 175, + 243, + 89, + 79, + 134, + 181, + 142, + 34, + 156, + 122, + 208, + 92, + 43, + 132, + 240 + ] + }, + { + "key": [ + 93, + 152, + 160, + 199, + 173, + 111, + 156, + 11, + 17, + 102, + 19, + 202, + 80, + 130, + 37, + 3, + 86, + 166, + 169, + 188, + 165, + 95, + 225, + 164, + 162, + 150, + 43, + 115, + 50, + 20, + 218, + 196 + ], + "nonce": [ + 139, + 45, + 142, + 141, + 131, + 189, + 214, + 163, + 18, + 93, + 217, + 151 + ], + "aad": [ + 47, + 32, + 99, + 109, + 70, + 206, + 55, + 233, + 187, + 12, + 160, + 196, + 29, + 129, + 158, + 62, + 171, + 206, + 218, + 203, + 209, + 202, + 60, + 237, + 17, + 45, + 58, + 214, + 32, + 187, + 211, + 178, + 239, + 254, + 128, + 211, + 236, + 135, + 96, + 112, + 110, + 143, + 20, + 219, + 131, + 19, + 154, + 112 + ], + "plaintext": [ + 79, + 54, + 133, + 194, + 207, + 188, + 133, + 99, + 121, + 209, + 253, + 0, + 249, + 97, + 31, + 228, + 192, + 164, + 185, + 196, + 1, + 63, + 225, + 190, + 225, + 68, + 68, + 151, + 9, + 166, + 167, + 227, + 31, + 246, + 251, + 13, + 167, + 78, + 212, + 100, + 176, + 102, + 176, + 59, + 80, + 241, + 156, + 215, + 245, + 249, + 188 + ], + "ciphertext": [ + 142, + 23, + 140, + 14, + 62, + 93, + 34, + 179, + 190, + 137, + 126, + 11, + 136, + 121, + 176, + 213, + 63, + 239, + 46, + 251, + 153, + 70, + 204, + 255, + 109, + 113, + 123, + 0, + 30, + 48, + 51, + 242, + 204, + 34, + 208, + 29, + 149, + 81, + 233, + 192, + 116, + 157, + 231, + 4, + 251, + 227, + 24, + 147, + 40, + 203, + 176 + ], + "tag": [ + 84, + 27, + 125, + 184, + 35, + 227, + 123, + 94, + 211, + 35, + 98, + 107, + 156, + 103, + 72, + 246 + ] + }, + { + "key": [ + 216, + 10, + 39, + 3, + 233, + 130, + 222, + 26, + 47, + 231, + 6, + 255, + 230, + 227, + 137, + 243, + 81, + 171, + 53, + 108, + 207, + 5, + 109, + 240, + 69, + 226, + 148, + 27, + 66, + 239, + 33, + 164 + ], + "nonce": [ + 21, + 33, + 171, + 143, + 114, + 66, + 203, + 160, + 84, + 39, + 244, + 41 + ], + "aad": [ + 83, + 149, + 222, + 144, + 214, + 190, + 199, + 193, + 89, + 171, + 157, + 108, + 250, + 102, + 59, + 220, + 98, + 149, + 208, + 37, + 225, + 252, + 200, + 183, + 96, + 185, + 186, + 66, + 215, + 133, + 237, + 162, + 24, + 218, + 188, + 111, + 167, + 192, + 247, + 51, + 173, + 119, + 246, + 22, + 130, + 191, + 242, + 219 + ], + "plaintext": [ + 111, + 159, + 222, + 40, + 232, + 87, + 118, + 164, + 156, + 251, + 173, + 20, + 89, + 217, + 70, + 17, + 117, + 122, + 60, + 217, + 150, + 170, + 110, + 45, + 112, + 45, + 4, + 131, + 164, + 216, + 141, + 83, + 33, + 49, + 235, + 212, + 5, + 179, + 81, + 34, + 107, + 22, + 209, + 157, + 48, + 211, + 40, + 7, + 161, + 213, + 17 + ], + "ciphertext": [ + 30, + 114, + 168, + 73, + 92, + 234, + 218, + 240, + 211, + 27, + 40, + 186, + 124, + 183, + 195, + 124, + 203, + 17, + 119, + 97, + 211, + 143, + 231, + 221, + 152, + 235, + 35, + 15, + 244, + 234, + 11, + 64, + 4, + 1, + 233, + 181, + 49, + 26, + 123, + 233, + 178, + 165, + 51, + 82, + 58, + 212, + 105, + 226, + 253, + 178, + 51 + ], + "tag": [ + 187, + 23, + 75, + 118, + 36, + 201, + 53, + 255, + 117, + 179, + 183, + 127, + 247, + 6, + 138, + 152 + ] + }, + { + "key": [ + 109, + 92, + 105, + 215, + 19, + 92, + 11, + 91, + 127, + 239, + 81, + 44, + 18, + 127, + 167, + 136, + 9, + 47, + 26, + 144, + 131, + 88, + 171, + 101, + 139, + 143, + 35, + 228, + 99, + 64, + 154, + 165 + ], + "nonce": [ + 179, + 108, + 204, + 173, + 56, + 205, + 97, + 72, + 163, + 132, + 160, + 38 + ], + "aad": [ + 177, + 159, + 70, + 22, + 187, + 20, + 82, + 37, + 26, + 42, + 125, + 191, + 120, + 249, + 32, + 25, + 79, + 19, + 158, + 4, + 36, + 210, + 118, + 131, + 98, + 29, + 30, + 225, + 232, + 101, + 115, + 124, + 36, + 102, + 224, + 88, + 67, + 156, + 142, + 18, + 46, + 88, + 42, + 123, + 99, + 96, + 124, + 233 + ], + "plaintext": [ + 180, + 231, + 79, + 92, + 86, + 242, + 234, + 5, + 109, + 159, + 249, + 49, + 82, + 89, + 68, + 223, + 173, + 32, + 126, + 6, + 59, + 162, + 38, + 195, + 84, + 224, + 50, + 10, + 80, + 68, + 153, + 103, + 233, + 100, + 88, + 13, + 155, + 87, + 2, + 140, + 20, + 0, + 90, + 186, + 104, + 101, + 248, + 188, + 106, + 62, + 248 + ], + "ciphertext": [ + 28, + 225, + 44, + 213, + 80, + 46, + 250, + 158, + 162, + 89, + 88, + 74, + 233, + 179, + 199, + 219, + 217, + 68, + 67, + 128, + 212, + 183, + 122, + 44, + 120, + 127, + 155, + 34, + 87, + 1, + 155, + 35, + 238, + 24, + 61, + 255, + 235, + 179, + 16, + 106, + 38, + 177, + 141, + 138, + 35, + 68, + 86, + 38, + 165, + 120, + 226 + ], + "tag": [ + 98, + 148, + 94, + 49, + 186, + 227, + 24, + 24, + 85, + 182, + 156, + 55, + 137, + 138, + 197, + 191 + ] + }, + { + "key": [ + 230, + 175, + 227, + 196, + 219, + 44, + 29, + 19, + 237, + 177, + 197, + 147, + 27, + 43, + 75, + 81, + 94, + 192, + 253, + 98, + 1, + 19, + 158, + 225, + 234, + 85, + 206, + 201, + 34, + 99, + 131, + 14 + ], + "nonce": [ + 53, + 139, + 217, + 234, + 100, + 23, + 125, + 30, + 35, + 164, + 23, + 38 + ], + "aad": [ + 126, + 15, + 132, + 28, + 221, + 215, + 238, + 235, + 209, + 236, + 123, + 123, + 141, + 14, + 47, + 113, + 101, + 110, + 94, + 159, + 243, + 207, + 167, + 57, + 192, + 185, + 208, + 236, + 73, + 65, + 160, + 179, + 243, + 179, + 150, + 105, + 13, + 190, + 95, + 80, + 130, + 214, + 251, + 109, + 215, + 1, + 198, + 141 + ], + "plaintext": [ + 113, + 11, + 179, + 57, + 75, + 9, + 78, + 231, + 208, + 83, + 188, + 101, + 153, + 178, + 109, + 175, + 211, + 55, + 232, + 166, + 28, + 88, + 13, + 4, + 70, + 195, + 191, + 25, + 94, + 119, + 202, + 81, + 50, + 200, + 236, + 58, + 71, + 166, + 21, + 121, + 220, + 227, + 131, + 96, + 187, + 167, + 198, + 94, + 77, + 86, + 52 + ], + "ciphertext": [ + 69, + 116, + 168, + 219, + 81, + 91, + 65, + 193, + 76, + 42, + 150, + 45, + 255, + 52, + 226, + 22, + 26, + 113, + 149, + 196, + 145, + 177, + 27, + 121, + 136, + 154, + 255, + 147, + 197, + 183, + 154, + 100, + 85, + 223, + 159, + 232, + 239, + 92, + 91, + 158, + 219, + 93, + 161, + 170, + 159, + 230, + 96, + 88, + 185, + 6, + 95 + ], + "tag": [ + 124, + 146, + 141, + 127, + 92, + 186, + 201, + 187, + 75, + 89, + 40, + 254, + 114, + 120, + 153, + 235 + ] + }, + { + "key": [ + 92, + 185, + 98, + 39, + 141, + 121, + 65, + 123, + 119, + 149, + 73, + 158, + 139, + 146, + 190, + 254, + 66, + 40, + 243, + 186, + 95, + 49, + 153, + 34, + 1, + 170, + 53, + 106, + 109, + 19, + 154, + 103 + ], + "nonce": [ + 118, + 247, + 231, + 96, + 143, + 9, + 160, + 95, + 51, + 105, + 148, + 207 + ], + "aad": [ + 3, + 45, + 227, + 253, + 236, + 39, + 63, + 200, + 68, + 108, + 43, + 247, + 103, + 226, + 1, + 242, + 199, + 193, + 144, + 172, + 249, + 214, + 211, + 33, + 162, + 74, + 4, + 98, + 203, + 195, + 53, + 110, + 121, + 143, + 226, + 61, + 108, + 27, + 79, + 232, + 59, + 233, + 201, + 93, + 113, + 192, + 85, + 4 + ], + "plaintext": [ + 46, + 18, + 203, + 212, + 104, + 8, + 106, + 167, + 14, + 46, + 205, + 29, + 222, + 245, + 97, + 232, + 92, + 34, + 93, + 208, + 131, + 229, + 149, + 111, + 92, + 103, + 80, + 51, + 68, + 176, + 234, + 152, + 43, + 181, + 4, + 77, + 175, + 188, + 192, + 42, + 91, + 155, + 225, + 233, + 185, + 136, + 144, + 45, + 128, + 23, + 43 + ], + "ciphertext": [ + 201, + 89, + 52, + 74, + 70, + 170, + 82, + 22, + 210, + 179, + 124, + 131, + 36, + 54, + 235, + 114, + 164, + 163, + 99, + 166, + 223, + 86, + 66, + 207, + 187, + 253, + 100, + 13, + 234, + 29, + 100, + 200, + 11, + 217, + 126, + 171, + 193, + 170, + 177, + 146, + 150, + 158, + 224, + 183, + 153, + 229, + 146, + 161, + 61, + 35, + 81 + ], + "tag": [ + 81, + 178, + 39, + 234, + 247, + 34, + 138, + 68, + 25, + 242, + 243, + 183, + 155, + 83, + 70, + 58 + ] + }, + { + "key": [ + 20, + 133, + 121, + 163, + 203, + 202, + 134, + 213, + 82, + 13, + 102, + 192, + 236, + 113, + 202, + 95, + 126, + 65, + 186, + 120, + 229, + 109, + 198, + 238, + 189, + 86, + 111, + 237, + 84, + 127, + 230, + 145 + ], + "nonce": [ + 176, + 138, + 94, + 161, + 146, + 116, + 153, + 198, + 236, + 191, + 212, + 224 + ], + "aad": [ + 228, + 249, + 99, + 240, + 21, + 255, + 187, + 153, + 238, + 51, + 73, + 187, + 175, + 126, + 142, + 142, + 108, + 42, + 113, + 194, + 48, + 164, + 143, + 157, + 89, + 134, + 10, + 41, + 9, + 29, + 39, + 71, + 224, + 26, + 92, + 165, + 114, + 52, + 126, + 36, + 125, + 37, + 245, + 107, + 167, + 174, + 142, + 5, + 205, + 226, + 190, + 60, + 151, + 147, + 18, + 146, + 192, + 35, + 112, + 32, + 142, + 205, + 9, + 126, + 246, + 146, + 104, + 127, + 236, + 242, + 244, + 25, + 211, + 32, + 1, + 98, + 166, + 72, + 10, + 87, + 218, + 212, + 8, + 160, + 223, + 235, + 73, + 46, + 44, + 93 + ], + "plaintext": [ + 157, + 11, + 21, + 253, + 241, + 189, + 89, + 95, + 145, + 248, + 179, + 171, + 192, + 247, + 222, + 201, + 39, + 223, + 212, + 121, + 153, + 53, + 161, + 121, + 93, + 156, + 224, + 12, + 155, + 135, + 148, + 52, + 66, + 15, + 228, + 44, + 39, + 90, + 124, + 215, + 179, + 157, + 99, + 143, + 184, + 28, + 165, + 43, + 73, + 220, + 65 + ], + "ciphertext": [ + 32, + 151, + 227, + 114, + 149, + 10, + 94, + 147, + 131, + 198, + 117, + 232, + 158, + 234, + 28, + 49, + 79, + 153, + 145, + 89, + 245, + 97, + 19, + 68, + 178, + 152, + 205, + 164, + 94, + 98, + 132, + 55, + 22, + 242, + 21, + 248, + 46, + 230, + 99, + 145, + 156, + 100, + 0, + 42, + 92, + 25, + 141, + 120, + 120, + 253, + 63 + ], + "tag": [ + 173, + 190, + 205, + 176, + 213, + 194, + 34, + 77, + 128, + 77, + 40, + 134, + 255, + 154, + 87, + 96 + ] + }, + { + "key": [ + 228, + 154, + 241, + 145, + 130, + 250, + 239, + 14, + 190, + 235, + 169, + 242, + 211, + 190, + 4, + 78, + 119, + 177, + 33, + 35, + 88, + 54, + 110, + 78, + 245, + 158, + 0, + 138, + 235, + 205, + 151, + 136 + ], + "nonce": [ + 231, + 243, + 125, + 121, + 166, + 164, + 135, + 165, + 167, + 3, + 237, + 187 + ], + "aad": [ + 25, + 169, + 161, + 207, + 198, + 71, + 52, + 103, + 129, + 190, + 245, + 30, + 217, + 7, + 13, + 5, + 249, + 154, + 14, + 1, + 146, + 162, + 35, + 197, + 205, + 37, + 34, + 219, + 223, + 151, + 217, + 115, + 157, + 211, + 159, + 177, + 120, + 173, + 227, + 51, + 158, + 104, + 119, + 75, + 5, + 138, + 160, + 62, + 154, + 32, + 169, + 162, + 5, + 188, + 5, + 243, + 35, + 129, + 223, + 77, + 99, + 57, + 110, + 246, + 145, + 254, + 253, + 90, + 113, + 180, + 154, + 42, + 216, + 45, + 94, + 164, + 40, + 119, + 140, + 164, + 126, + 225, + 57, + 135, + 146, + 118, + 36, + 19, + 207, + 244 + ], + "plaintext": [ + 70, + 28, + 208, + 202, + 247, + 66, + 122, + 61, + 68, + 64, + 141, + 130, + 94, + 215, + 25, + 35, + 114, + 114, + 236, + 213, + 3, + 185, + 9, + 77, + 31, + 98, + 201, + 125, + 99, + 237, + 131, + 160, + 181, + 11, + 220, + 128, + 79, + 253, + 215, + 153, + 29, + 167, + 165, + 182, + 220, + 244, + 141, + 75, + 205, + 44, + 188 + ], + "ciphertext": [ + 50, + 202, + 53, + 136, + 227, + 229, + 110, + 180, + 200, + 48, + 27, + 0, + 157, + 139, + 132, + 184, + 169, + 0, + 178, + 184, + 140, + 163, + 194, + 25, + 68, + 32, + 94, + 157, + 215, + 49, + 23, + 87, + 181, + 19, + 148, + 174, + 144, + 216, + 187, + 56, + 7, + 180, + 113, + 103, + 118, + 20, + 244, + 25, + 138, + 249, + 9 + ], + "tag": [ + 62, + 64, + 61, + 3, + 92, + 113, + 216, + 143, + 27, + 225, + 162, + 86, + 200, + 155, + 166, + 173 + ] + }, + { + "key": [ + 194, + 119, + 223, + 4, + 93, + 10, + 26, + 57, + 86, + 149, + 143, + 39, + 16, + 85, + 194, + 41, + 210, + 99, + 68, + 39, + 177, + 215, + 62, + 153, + 213, + 73, + 32, + 218, + 105, + 247, + 46, + 1 + ], + "nonce": [ + 121, + 226, + 79, + 132, + 188, + 119, + 162, + 26, + 108, + 177, + 78, + 226 + ], + "aad": [ + 202, + 9, + 40, + 34, + 56, + 212, + 146, + 2, + 154, + 251, + 211, + 14, + 169, + 180, + 170, + 157, + 68, + 141, + 119, + 180, + 180, + 26, + 121, + 28, + 53, + 235, + 227, + 248, + 229, + 3, + 74, + 199, + 18, + 16, + 17, + 122, + 132, + 63, + 174, + 100, + 124, + 234, + 2, + 7, + 18, + 194, + 126, + 92, + 143, + 133, + 172, + 249, + 51, + 213, + 226, + 132, + 48, + 199, + 119, + 8, + 98, + 216, + 219, + 177, + 151, + 203, + 188, + 254, + 73, + 221, + 99, + 246, + 170, + 5, + 251, + 209, + 62, + 50, + 196, + 89, + 52, + 38, + 152, + 223, + 238, + 89, + 53, + 199, + 195, + 33 + ], + "plaintext": [ + 92, + 166, + 141, + 133, + 140, + 195, + 11, + 28, + 176, + 81, + 76, + 78, + 157, + 233, + 142, + 26, + 26, + 131, + 93, + 244, + 1, + 246, + 158, + 158, + 198, + 241, + 188, + 177, + 21, + 143, + 9, + 17, + 77, + 255, + 85, + 22, + 131, + 179, + 130, + 116, + 87, + 247, + 126, + 23, + 167, + 9, + 123, + 30, + 166, + 158, + 172 + ], + "ciphertext": [ + 92, + 82, + 35, + 200, + 237, + 165, + 154, + 141, + 194, + 139, + 8, + 230, + 194, + 20, + 130, + 164, + 110, + 93, + 132, + 211, + 44, + 112, + 80, + 191, + 20, + 79, + 197, + 127, + 78, + 128, + 148, + 222, + 19, + 49, + 152, + 218, + 123, + 75, + 131, + 152, + 177, + 103, + 32, + 74, + 255, + 131, + 125, + 161, + 93, + 154, + 178 + ], + "tag": [ + 55, + 136, + 133, + 149, + 10, + 68, + 145, + 190, + 227, + 205, + 104, + 29, + 60, + 149, + 123, + 154 + ] + }, + { + "key": [ + 77, + 7, + 247, + 141, + 25, + 230, + 216, + 187, + 50, + 191, + 32, + 159, + 19, + 131, + 7, + 137, + 15, + 15, + 26, + 227, + 147, + 98, + 119, + 159, + 242, + 191, + 31, + 155, + 115, + 79, + 230, + 83 + ], + "nonce": [ + 217, + 131, + 165, + 213, + 175, + 120, + 163, + 177, + 205, + 95, + 189, + 88 + ], + "aad": [ + 163, + 220, + 159, + 249, + 33, + 11, + 196, + 179, + 39, + 105, + 9, + 136, + 61, + 178, + 194, + 170, + 7, + 98, + 205, + 34, + 180, + 105, + 1, + 162, + 72, + 192, + 55, + 45, + 7, + 62, + 119, + 120, + 185, + 193, + 216, + 70, + 155, + 38, + 187, + 66, + 64, + 110, + 72, + 78, + 247, + 116, + 127, + 113, + 222, + 167, + 133, + 252, + 0, + 32, + 162, + 234, + 193, + 126, + 10, + 195, + 251, + 224, + 69, + 54, + 41, + 239, + 214, + 141, + 86, + 120, + 251, + 236, + 193, + 10, + 248, + 255, + 190, + 120, + 40, + 248, + 38, + 222, + 251, + 99, + 135, + 99, + 244, + 236, + 254, + 130 + ], + "plaintext": [ + 148, + 240, + 187, + 196, + 52, + 13, + 151, + 216, + 84, + 226, + 92, + 199, + 206, + 133, + 234, + 30, + 120, + 30, + 104, + 191, + 111, + 99, + 158, + 10, + 152, + 27, + 176, + 62, + 60, + 32, + 156, + 191, + 81, + 39, + 23, + 28, + 176, + 255, + 246, + 91, + 195, + 236, + 172, + 146, + 119, + 77, + 16, + 20, + 109, + 26, + 197 + ], + "ciphertext": [ + 101, + 67, + 180, + 217, + 127, + 204, + 210, + 115, + 179, + 100, + 54, + 254, + 247, + 25, + 172, + 49, + 191, + 14, + 92, + 76, + 5, + 142, + 167, + 26, + 234, + 42, + 14, + 91, + 96, + 227, + 41, + 190, + 110, + 168, + 28, + 227, + 134, + 230, + 233, + 254, + 68, + 128, + 229, + 131, + 99, + 195, + 178, + 3, + 104, + 101, + 172 + ], + "tag": [ + 146, + 76, + 247, + 192, + 119, + 15, + 34, + 138, + 75, + 146, + 233, + 178, + 161, + 31, + 199, + 11 + ] + }, + { + "key": [ + 149, + 114, + 185, + 197, + 122, + 189, + 241, + 202, + 174, + 59, + 235, + 192, + 228, + 187, + 249, + 229, + 86, + 181, + 203, + 172, + 202, + 44, + 71, + 86, + 5, + 15, + 239, + 209, + 10, + 102, + 97, + 85 + ], + "nonce": [ + 222, + 41, + 42, + 152, + 88, + 202, + 172, + 205, + 202, + 182, + 164, + 51 + ], + "aad": [ + 160, + 66, + 217, + 122, + 155, + 143, + 108, + 175, + 81, + 197, + 242, + 69, + 34, + 215, + 237, + 131, + 226, + 197, + 216, + 236, + 107, + 55, + 239, + 37, + 152, + 19, + 74, + 48, + 229, + 115, + 25, + 48, + 12, + 63, + 223, + 146, + 251, + 29, + 151, + 151, + 245, + 239, + 0, + 151, + 31, + 102, + 42, + 174, + 118, + 143, + 105, + 249, + 202, + 4, + 85, + 189, + 109, + 16, + 89, + 213, + 248, + 91, + 142, + 203, + 151, + 112, + 6, + 184, + 51, + 249, + 10, + 194, + 213, + 187, + 244, + 73, + 140, + 131, + 244, + 209, + 164, + 37, + 132, + 192, + 223, + 196, + 162, + 226, + 69, + 60 + ], + "plaintext": [ + 111, + 66, + 10, + 50, + 112, + 140, + 205, + 77, + 240, + 211, + 20, + 158, + 140, + 29, + 136, + 220, + 235, + 166, + 110, + 228, + 84, + 111, + 56, + 219, + 7, + 4, + 110, + 191, + 48, + 244, + 118, + 39, + 247, + 253, + 218, + 29, + 215, + 151, + 131, + 173, + 171, + 229, + 246, + 182, + 133, + 56, + 87, + 185, + 155, + 134, + 76 + ], + "ciphertext": [ + 169, + 175, + 150, + 29, + 97, + 171, + 87, + 140, + 193, + 52, + 142, + 182, + 247, + 41, + 96, + 63, + 72, + 28, + 93, + 155, + 249, + 190, + 227, + 161, + 62, + 218, + 2, + 43, + 208, + 156, + 3, + 164, + 242, + 7, + 194, + 28, + 69, + 192, + 35, + 42, + 151, + 66, + 174, + 143, + 12, + 84, + 180, + 39, + 138, + 58, + 99 + ], + "tag": [ + 239, + 249, + 187, + 38, + 21, + 110, + 199, + 111, + 0, + 96, + 205, + 147, + 169, + 89, + 224, + 85 + ] + }, + { + "key": [ + 60, + 200, + 103, + 28, + 77, + 37, + 195, + 203, + 200, + 135, + 244, + 220, + 189, + 100, + 229, + 49, + 233, + 28, + 246, + 37, + 47, + 110, + 233, + 194, + 157, + 153, + 136, + 210, + 10, + 182, + 116, + 127 + ], + "nonce": [ + 249, + 96, + 160, + 156, + 11, + 80, + 103, + 40, + 9, + 38, + 169, + 195 + ], + "aad": [ + 121, + 215, + 58, + 127, + 248, + 102, + 152, + 230, + 17, + 74, + 15, + 70, + 83, + 115, + 251, + 238, + 2, + 158, + 4, + 36, + 36, + 196, + 57, + 178, + 46, + 58, + 211, + 123, + 54, + 185, + 224, + 43, + 171, + 130, + 225, + 104, + 68, + 17, + 78, + 153, + 227, + 156, + 22, + 159, + 70, + 47, + 230, + 27, + 135, + 196, + 98, + 124, + 57, + 67, + 132, + 172, + 201, + 83, + 22, + 128, + 112, + 110, + 78, + 86, + 73, + 26, + 48, + 76, + 96, + 117, + 204, + 163, + 124, + 100, + 219, + 36, + 70, + 140, + 31, + 185, + 81, + 150, + 5, + 200, + 63, + 14, + 227, + 224, + 49, + 106 + ], + "plaintext": [ + 91, + 88, + 113, + 123, + 11, + 50, + 7, + 101, + 102, + 181, + 139, + 243, + 124, + 97, + 51, + 230, + 20, + 104, + 178, + 190, + 103, + 113, + 95, + 176, + 0, + 127, + 227, + 144, + 196, + 181, + 87, + 141, + 236, + 245, + 85, + 2, + 164, + 227, + 193, + 46, + 123, + 223, + 11, + 169, + 135, + 132, + 209, + 38, + 228, + 117, + 58 + ], + "ciphertext": [ + 29, + 11, + 224, + 151, + 71, + 12, + 26, + 195, + 6, + 25, + 246, + 60, + 57, + 97, + 21, + 42, + 178, + 125, + 184, + 140, + 230, + 148, + 183, + 187, + 164, + 219, + 24, + 92, + 179, + 24, + 3, + 204, + 123, + 171, + 137, + 14, + 147, + 28, + 144, + 118, + 102, + 33, + 191, + 229, + 216, + 135, + 235, + 12, + 214, + 153, + 93 + ], + "tag": [ + 219, + 213, + 126, + 160, + 145, + 255, + 22, + 252, + 125, + 188, + 84, + 53, + 3, + 12, + 199, + 78 + ] + }, + { + "key": [ + 136, + 32, + 104, + 190, + 69, + 82, + 215, + 173, + 34, + 79, + 200, + 250, + 42, + 240, + 13, + 106, + 191, + 118, + 204, + 241, + 167, + 104, + 157, + 117, + 246, + 240, + 233, + 189, + 130, + 193, + 33, + 94 + ], + "nonce": [ + 137, + 10, + 83, + 21, + 153, + 47, + 18, + 103, + 77, + 28, + 128, + 24 + ], + "aad": [ + 145, + 103, + 33, + 223, + 129, + 107, + 28, + 173, + 83, + 29, + 238, + 142, + 74, + 142, + 99, + 77, + 67, + 237, + 135, + 219, + 153, + 96, + 155, + 204, + 152, + 109, + 22, + 191, + 172, + 44, + 255, + 87, + 125, + 83, + 109, + 116, + 154, + 92, + 54, + 37, + 222, + 83, + 197, + 53, + 24, + 37, + 194, + 40, + 145, + 31, + 10, + 100, + 190, + 31, + 201, + 115, + 138, + 38, + 57, + 78, + 254, + 83, + 50, + 192, + 118, + 43, + 245, + 155, + 101, + 211, + 241, + 197, + 170, + 250, + 156, + 162, + 230, + 62, + 204, + 213, + 149, + 104, + 230, + 192, + 38, + 153, + 80, + 145, + 26, + 113 + ], + "plaintext": [ + 132, + 100, + 192, + 62, + 2, + 128, + 203, + 31, + 99, + 192, + 84, + 162, + 74, + 5, + 14, + 152, + 15, + 96, + 204, + 115, + 19, + 240, + 159, + 32, + 146, + 196, + 93, + 119, + 187, + 233, + 173, + 42, + 140, + 31, + 108, + 220, + 162, + 172, + 216, + 197, + 124, + 135, + 232, + 135, + 237, + 173, + 182, + 107, + 203, + 102, + 196 + ], + "ciphertext": [ + 2, + 14, + 41, + 125, + 144, + 113, + 119, + 219, + 161, + 45, + 222, + 75, + 254, + 27, + 15, + 249, + 182, + 169, + 217, + 219, + 6, + 149, + 25, + 62, + 65, + 129, + 68, + 158, + 21, + 113, + 55, + 181, + 155, + 72, + 134, + 22, + 186, + 21, + 27, + 6, + 216, + 137, + 248, + 73, + 140, + 227, + 115, + 210, + 57, + 106, + 185 + ], + "tag": [ + 228, + 133, + 55, + 236, + 178, + 116, + 96, + 180, + 119, + 166, + 231, + 195, + 70, + 61, + 188, + 176 + ] + }, + { + "key": [ + 77, + 234, + 220, + 240, + 247, + 225, + 146, + 49, + 248, + 175, + 203, + 111, + 185, + 2, + 177, + 5, + 190, + 242, + 63, + 47, + 169, + 50, + 58, + 81, + 131, + 63, + 248, + 54, + 140, + 203, + 79, + 145 + ], + "nonce": [ + 109, + 77, + 1, + 171, + 213, + 135, + 237, + 17, + 14, + 81, + 46, + 210 + ], + "aad": [ + 49, + 162, + 121, + 115, + 24, + 16, + 75, + 45, + 201, + 151, + 126, + 89, + 148, + 53, + 176, + 65, + 197, + 107, + 175, + 229, + 231, + 217, + 1, + 165, + 134, + 20, + 194, + 211, + 251, + 157, + 34, + 14, + 63, + 211, + 226, + 130, + 140, + 239, + 105, + 224, + 96, + 78, + 215, + 51, + 64, + 203, + 30, + 33, + 150, + 114, + 148, + 220, + 216, + 116, + 137, + 57, + 66, + 68, + 34, + 0, + 178, + 165, + 184, + 96, + 238, + 140, + 249, + 30, + 29, + 142, + 179, + 211, + 100, + 208, + 228, + 62, + 132, + 246, + 55, + 159, + 67, + 74, + 26, + 225, + 124, + 35, + 107, + 33, + 104, + 66 + ], + "plaintext": [ + 117, + 104, + 110, + 15, + 221, + 63, + 217, + 111, + 62, + 109, + 250, + 253, + 122, + 42, + 144, + 127, + 159, + 55, + 93, + 147, + 148, + 60, + 178, + 34, + 155, + 215, + 43, + 3, + 43, + 246, + 36, + 175, + 79, + 199, + 32, + 113, + 40, + 147, + 134, + 227, + 220, + 204, + 69, + 149, + 158, + 71, + 171, + 66, + 178, + 97, + 162 + ], + "ciphertext": [ + 143, + 234, + 249, + 160, + 137, + 89, + 152, + 18, + 17, + 122, + 103, + 174, + 210, + 244, + 191, + 52, + 49, + 255, + 31, + 108, + 253, + 100, + 234, + 95, + 244, + 117, + 40, + 122, + 187, + 79, + 241, + 171, + 107, + 62, + 79, + 138, + 85, + 209, + 198, + 179, + 240, + 133, + 148, + 244, + 3, + 231, + 113, + 236, + 126, + 153, + 86 + ], + "tag": [ + 80, + 64, + 64, + 118, + 33, + 113, + 46, + 5, + 53, + 145, + 23, + 158, + 22, + 137, + 105, + 142 + ] + }, + { + "key": [ + 128, + 241, + 197, + 21, + 241, + 13, + 121, + 205, + 190, + 226, + 117, + 33, + 58, + 169, + 172, + 8, + 69, + 226, + 207, + 66, + 135, + 79, + 126, + 105, + 80, + 129, + 203, + 16, + 58, + 191, + 26, + 39 + ], + "nonce": [ + 57, + 157, + 95, + 155, + 33, + 139, + 98, + 255, + 96, + 194, + 103, + 189 + ], + "aad": [ + 210, + 168, + 255, + 248, + 174, + 36, + 166, + 165, + 239, + 199, + 87, + 100, + 84, + 154, + 118, + 82, + 34, + 223, + 49, + 126, + 50, + 58, + 121, + 140, + 187, + 138, + 35, + 209, + 175, + 143, + 223, + 138, + 59, + 118, + 127, + 85, + 112, + 59, + 28, + 15, + 235, + 163, + 145, + 45, + 66, + 52, + 68, + 25, + 120, + 25, + 18, + 98, + 241, + 153, + 156, + 105, + 202, + 164, + 233, + 163, + 224, + 69, + 76, + 20, + 58, + 240, + 2, + 44, + 214, + 228, + 76, + 236, + 20, + 20, + 159, + 158, + 153, + 100, + 161, + 242, + 197, + 229, + 166, + 227, + 231, + 104, + 189, + 135, + 0, + 96 + ], + "plaintext": [ + 158, + 149, + 34, + 24, + 115, + 246, + 82, + 130, + 221, + 30, + 199, + 84, + 148, + 210, + 80, + 14, + 98, + 162, + 182, + 237, + 218, + 90, + 111, + 51, + 179, + 212, + 221, + 117, + 22, + 239, + 37, + 207, + 65, + 84, + 71, + 46, + 97, + 198, + 174, + 210, + 116, + 156, + 90, + 125, + 134, + 99, + 112, + 82, + 176, + 15, + 84 + ], + "ciphertext": [ + 79, + 153, + 101, + 98, + 226, + 62, + 187, + 253, + 79, + 226, + 101, + 35, + 174, + 233, + 82, + 91, + 19, + 214, + 225, + 52, + 231, + 45, + 33, + 189, + 199, + 241, + 149, + 198, + 64, + 53, + 1, + 253, + 131, + 0, + 182, + 229, + 151, + 182, + 104, + 241, + 153, + 249, + 53, + 145, + 186, + 116, + 42, + 145, + 181, + 68, + 84 + ], + "tag": [ + 45, + 161, + 199, + 50, + 95, + 88, + 87, + 93, + 39, + 90, + 191, + 150, + 199, + 250, + 158, + 81 + ] + }, + { + "key": [ + 194, + 198, + 233, + 190, + 90, + 72, + 10, + 74, + 86, + 191, + 205, + 14, + 38, + 143, + 170, + 34, + 118, + 9, + 59, + 209, + 247, + 232, + 206, + 97, + 231, + 70, + 208, + 3, + 222, + 204, + 118, + 30 + ], + "nonce": [ + 193, + 84, + 30, + 178, + 87, + 33, + 212, + 133, + 109, + 248, + 249, + 40 + ], + "aad": [ + 243, + 78, + 121, + 229, + 254, + 67, + 126, + 218, + 3, + 204, + 254, + 242, + 241, + 214, + 49, + 157, + 245, + 26, + 113, + 201, + 137, + 24, + 99, + 228, + 185, + 138, + 114, + 152, + 189, + 100, + 73, + 4, + 96, + 53, + 77, + 181, + 162, + 139, + 15, + 173, + 203, + 129, + 80, + 36, + 234, + 23, + 243, + 184, + 72, + 16, + 226, + 121, + 84, + 175, + 177, + 253, + 244, + 79, + 13, + 239, + 185, + 48, + 177, + 121, + 54, + 132, + 167, + 129, + 49, + 11, + 154, + 249, + 91, + 75, + 207, + 10, + 114, + 122, + 44, + 176, + 172, + 82, + 155, + 128, + 88, + 17, + 179, + 114, + 29, + 152 + ], + "plaintext": [ + 135, + 210, + 46, + 3, + 24, + 251, + 187, + 66, + 11, + 134, + 176, + 88, + 91, + 209, + 44, + 20, + 100, + 95, + 242, + 199, + 66, + 229, + 99, + 155, + 58, + 17, + 76, + 201, + 108, + 95, + 115, + 142, + 223, + 190, + 32, + 85, + 17, + 111, + 37, + 158, + 61, + 108, + 20, + 203, + 109, + 143, + 202, + 69, + 112, + 130, + 137 + ], + "ciphertext": [ + 181, + 214, + 229, + 124, + 122, + 160, + 36, + 14, + 11, + 110, + 51, + 45, + 59, + 51, + 35, + 181, + 37, + 163, + 216, + 165, + 83, + 173, + 4, + 27, + 165, + 153, + 233, + 9, + 24, + 141, + 165, + 55, + 195, + 41, + 61, + 22, + 135, + 251, + 150, + 120, + 130, + 209, + 106, + 86, + 21, + 184, + 78, + 149, + 249, + 221, + 119 + ], + "tag": [ + 28, + 206, + 51, + 76, + 236, + 75, + 81, + 33, + 108, + 172, + 15, + 198, + 32, + 205, + 173, + 249 + ] + }, + { + "key": [ + 234, + 13, + 97, + 132, + 167, + 20, + 86, + 226, + 127, + 154, + 200, + 45, + 252, + 127, + 102, + 148, + 200, + 152, + 247, + 192, + 209, + 157, + 28, + 176, + 219, + 78, + 87, + 93, + 208, + 9, + 75, + 182 + ], + "nonce": [ + 80, + 24, + 251, + 129, + 109, + 81, + 85, + 17, + 191, + 185, + 57, + 213 + ], + "aad": [ + 139, + 198, + 189, + 10, + 38, + 50, + 18, + 189, + 114, + 129, + 253, + 26, + 69, + 229, + 18, + 252, + 161, + 4, + 248, + 89, + 53, + 142, + 174, + 146, + 147, + 162, + 151, + 197, + 41, + 160, + 171, + 175, + 253, + 138, + 119, + 80, + 123, + 144, + 105, + 4, + 15, + 43, + 49, + 65, + 167, + 98, + 6, + 145, + 225, + 16, + 168, + 181, + 147, + 185, + 86, + 216, + 227, + 231, + 22, + 148, + 80, + 107, + 137, + 1, + 138, + 3, + 134, + 28, + 27, + 166, + 8, + 38, + 135, + 173, + 206, + 21, + 168, + 116, + 199, + 52, + 119, + 67, + 12, + 239, + 7, + 94, + 186, + 7, + 122, + 147 + ], + "plaintext": [ + 8, + 49, + 71, + 208, + 200, + 15, + 19, + 79, + 115, + 147, + 133, + 92, + 138, + 149, + 191, + 110, + 106, + 189, + 111, + 154, + 123, + 31, + 202, + 88, + 78, + 139, + 252, + 107, + 93, + 193, + 58, + 142, + 219, + 253, + 71, + 62, + 35, + 44, + 4, + 29, + 155, + 233, + 238, + 119, + 9, + 220, + 134, + 179, + 170, + 50, + 10 + ], + "ciphertext": [ + 240, + 165, + 196, + 148, + 23, + 130, + 226, + 242, + 148, + 29, + 208, + 90, + 206, + 226, + 155, + 101, + 52, + 23, + 115, + 242, + 232, + 213, + 25, + 53, + 163, + 244, + 250, + 111, + 38, + 143, + 240, + 48, + 200, + 128, + 151, + 108, + 241, + 238, + 133, + 143, + 101, + 113, + 171, + 216, + 65, + 27, + 105, + 90, + 47, + 173, + 240 + ], + "tag": [ + 6, + 125, + 140, + 194, + 211, + 140, + 48, + 105, + 114, + 114, + 218, + 160, + 12, + 127, + 112, + 207 + ] + }, + { + "key": [ + 198, + 36, + 254, + 182, + 203, + 13, + 120, + 214, + 52, + 182, + 39, + 19, + 76, + 105, + 47, + 11, + 245, + 222, + 191, + 132, + 216, + 99, + 158, + 34, + 255, + 39, + 206, + 42, + 206, + 73, + 212, + 56 + ], + "nonce": [ + 165, + 79, + 79, + 18, + 4, + 37, + 95, + 107, + 49, + 34, + 34, + 205 + ], + "aad": [ + 217, + 9, + 155, + 166, + 190, + 80, + 220, + 167, + 126, + 11, + 152, + 3, + 118, + 106, + 217, + 147, + 19, + 36, + 121, + 251, + 171, + 67, + 184, + 244, + 18, + 106, + 127, + 158, + 246, + 115, + 172, + 12, + 175, + 45, + 226, + 53, + 225, + 232, + 74, + 217, + 254, + 80, + 92, + 67, + 209, + 172, + 119, + 159, + 80, + 114, + 192, + 37, + 193, + 78, + 160, + 217, + 48, + 206, + 57, + 219, + 140, + 89, + 48, + 186, + 173, + 162, + 59, + 62, + 70, + 84, + 71, + 14, + 85, + 159, + 203, + 110, + 177, + 193, + 51, + 167, + 115, + 24, + 184, + 124, + 199, + 145, + 62, + 18, + 212, + 4 + ], + "plaintext": [ + 236, + 52, + 244, + 92, + 27, + 112, + 253, + 86, + 81, + 140, + 197, + 196, + 4, + 204, + 19, + 51, + 10, + 183, + 213, + 28, + 16, + 244, + 210, + 207, + 235, + 38, + 176, + 151, + 174, + 118, + 137, + 113, + 145, + 236, + 27, + 57, + 83, + 176, + 8, + 110, + 66, + 92, + 125, + 162, + 33, + 210, + 159, + 101, + 213, + 204, + 243 + ], + "ciphertext": [ + 113, + 61, + 40, + 165, + 18, + 61, + 101, + 232, + 44, + 202, + 110, + 127, + 217, + 25, + 225, + 229, + 227, + 189, + 170, + 177, + 42, + 231, + 21, + 207, + 139, + 124, + 151, + 78, + 181, + 246, + 43, + 232, + 195, + 180, + 38, + 55, + 7, + 76, + 107, + 137, + 31, + 108, + 96, + 51, + 235, + 75, + 126, + 97, + 219, + 159, + 11 + ], + "tag": [ + 1, + 237, + 237, + 255, + 110, + 77, + 29, + 206, + 74, + 199, + 144, + 33, + 142, + 32, + 142, + 190 + ] + }, + { + "key": [ + 26, + 252, + 104, + 179, + 37, + 150, + 25, + 138, + 224, + 243, + 168, + 97, + 39, + 81, + 194, + 65, + 51, + 34, + 232, + 5, + 79, + 242, + 172, + 107, + 237, + 227, + 212, + 161, + 238, + 32, + 238, + 98 + ], + "nonce": [ + 53, + 104, + 96, + 231, + 110, + 121, + 68, + 146, + 222, + 106, + 104, + 243 + ], + "aad": [ + 32, + 94, + 68, + 0, + 158, + 14, + 249, + 99, + 131, + 138, + 255, + 97, + 91, + 53, + 201, + 241, + 39, + 29, + 72, + 124, + 247, + 25, + 103, + 125, + 149, + 103, + 24, + 188, + 232, + 171, + 103, + 108, + 206, + 182, + 54, + 173, + 56, + 20, + 50, + 197, + 199, + 144, + 194, + 107, + 7, + 5, + 27, + 102, + 26, + 47, + 236, + 78, + 96, + 127, + 150, + 68, + 248, + 73, + 147, + 200, + 51, + 93, + 178, + 26, + 227, + 107, + 96, + 8, + 186, + 178, + 136, + 58, + 215, + 84, + 24, + 9, + 191, + 95, + 73, + 39, + 34, + 149, + 193, + 193, + 241, + 207, + 140, + 103, + 133, + 83 + ], + "plaintext": [ + 41, + 48, + 65, + 3, + 143, + 158, + 142, + 222, + 226, + 61, + 47, + 24, + 188, + 232, + 123, + 82, + 35, + 128, + 241, + 250, + 24, + 179, + 2, + 24, + 48, + 165, + 74, + 184, + 145, + 218, + 133, + 72, + 9, + 82, + 40, + 237, + 152, + 96, + 23, + 97, + 82, + 226, + 121, + 69, + 214, + 98, + 84, + 240, + 219, + 133, + 144 + ], + "ciphertext": [ + 224, + 97, + 9, + 104, + 13, + 95, + 239, + 211, + 69, + 102, + 94, + 201, + 165, + 178, + 231, + 191, + 62, + 206, + 58, + 241, + 182, + 40, + 65, + 169, + 92, + 69, + 62, + 119, + 83, + 181, + 161, + 214, + 216, + 161, + 11, + 60, + 108, + 66, + 223, + 31, + 35, + 131, + 43, + 116, + 231, + 72, + 113, + 130, + 31, + 28, + 11 + ], + "tag": [ + 149, + 61, + 141, + 4, + 247, + 14, + 42, + 240, + 85, + 172, + 144, + 42, + 69, + 82, + 53, + 178 + ] + }, + { + "key": [ + 246, + 27, + 114, + 51, + 89, + 231, + 152, + 254, + 254, + 204, + 38, + 177, + 11, + 22, + 141, + 195, + 49, + 198, + 57, + 7, + 149, + 152, + 241, + 246, + 81, + 22, + 108, + 197, + 140, + 103, + 30, + 225 + ], + "nonce": [ + 176, + 126, + 148, + 7, + 181, + 146, + 212, + 253, + 149, + 80, + 147, + 67 + ], + "aad": [ + 20, + 41, + 198, + 242, + 120, + 40, + 203, + 148, + 173, + 94, + 98, + 69, + 29, + 161, + 15, + 213, + 116, + 102, + 12, + 236, + 43, + 143, + 39, + 154, + 25, + 187, + 184, + 161, + 103, + 166, + 48, + 211, + 172, + 96, + 219, + 4, + 232, + 250, + 160, + 34, + 4, + 121, + 46, + 73, + 174, + 212, + 80, + 24, + 68, + 164, + 25, + 211, + 236, + 223, + 240, + 208, + 55, + 153, + 134, + 111, + 238, + 129, + 169, + 17, + 135, + 176, + 138, + 68, + 213, + 187, + 97, + 127, + 243, + 178, + 206, + 247, + 156, + 212, + 135, + 80, + 234, + 32, + 144, + 62, + 29, + 54, + 39, + 161, + 119, + 48 + ], + "plaintext": [ + 39, + 36, + 241, + 173, + 107, + 91, + 64, + 154, + 89, + 199, + 242, + 255, + 100, + 158, + 178, + 75, + 74, + 51, + 160, + 61, + 122, + 4, + 38, + 226, + 154, + 110, + 163, + 170, + 145, + 180, + 240, + 6, + 153, + 251, + 237, + 117, + 187, + 113, + 137, + 150, + 67, + 3, + 226, + 233, + 254, + 58, + 126, + 95, + 116, + 183, + 161 + ], + "ciphertext": [ + 54, + 43, + 173, + 141, + 233, + 67, + 220, + 232, + 245, + 62, + 223, + 104, + 45, + 2, + 225, + 216, + 147, + 194, + 60, + 82, + 114, + 177, + 63, + 211, + 91, + 73, + 47, + 132, + 119, + 8, + 58, + 140, + 52, + 2, + 125, + 179, + 43, + 97, + 49, + 147, + 31, + 3, + 85, + 90, + 197, + 251, + 198, + 219, + 177, + 56, + 1 + ], + "tag": [ + 165, + 23, + 117, + 96, + 99, + 67, + 117, + 86, + 145, + 241, + 37, + 1, + 155, + 68, + 253, + 252 + ] + }, + { + "key": [ + 107, + 231, + 244, + 209, + 143, + 240, + 251, + 221, + 155, + 59, + 60, + 172, + 171, + 164, + 98, + 154, + 12, + 97, + 115, + 135, + 7, + 154, + 221, + 98, + 246, + 206, + 21, + 132, + 179, + 63, + 170, + 209 + ], + "nonce": [ + 253, + 165, + 104, + 201, + 203, + 19, + 217, + 193, + 118, + 188, + 239, + 3 + ], + "aad": [ + 17, + 235, + 235, + 151, + 221, + 74, + 153, + 37, + 193, + 251, + 226, + 185, + 175, + 119, + 57, + 32, + 88, + 210, + 217, + 113, + 228, + 45, + 177, + 93, + 163, + 159, + 9, + 13, + 123, + 193, + 50, + 87, + 60, + 52, + 191, + 125, + 146, + 162, + 215, + 45, + 198, + 110, + 230, + 132, + 12, + 63, + 240, + 121, + 133, + 184, + 151, + 110, + 232, + 216, + 243, + 107, + 244, + 122, + 227, + 48, + 184, + 153, + 253, + 198, + 6, + 82, + 221, + 90, + 35, + 196, + 95, + 54, + 128, + 241, + 25, + 81, + 240, + 25, + 224, + 105, + 124, + 138, + 207, + 202, + 169, + 95, + 1, + 185, + 199, + 221 + ], + "plaintext": [ + 77, + 246, + 104, + 233, + 157, + 80, + 104, + 96, + 74, + 72, + 188, + 202, + 91, + 170, + 130, + 69, + 67, + 89, + 40, + 85, + 138, + 131, + 214, + 141, + 123, + 11, + 8, + 24, + 97, + 34, + 78, + 155, + 211, + 158, + 168, + 242, + 213, + 90, + 99, + 89, + 73, + 230, + 108, + 111, + 106, + 127, + 245, + 204, + 52, + 221, + 148 + ], + "ciphertext": [ + 72, + 139, + 64, + 173, + 89, + 78, + 24, + 69, + 204, + 221, + 158, + 148, + 103, + 252, + 94, + 26, + 251, + 191, + 222, + 52, + 229, + 125, + 69, + 191, + 205, + 48, + 182, + 28, + 195, + 38, + 213, + 127, + 232, + 227, + 243, + 26, + 57, + 205, + 235, + 240, + 15, + 96, + 187, + 210, + 195, + 205, + 246, + 159, + 117, + 110, + 255 + ], + "tag": [ + 59, + 243, + 251, + 171, + 155, + 72, + 72, + 111, + 208, + 138, + 85, + 82, + 96, + 77, + 246, + 57 + ] + } +] diff --git a/tests/unit_node/dgram_test.ts b/tests/unit_node/dgram_test.ts new file mode 100644 index 000000000..4c6e49577 --- /dev/null +++ b/tests/unit_node/dgram_test.ts @@ -0,0 +1,59 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import { assertEquals } from "@test_util/std/assert/mod.ts"; +import { execCode } from "../unit/test_util.ts"; +import { createSocket } from "node:dgram"; + +const listenPort = 4503; +const listenPort2 = 4504; + +Deno.test("[node/dgram] udp ref and unref", { + permissions: { read: true, run: true, net: true }, +}, async () => { + const { promise, resolve } = Promise.withResolvers<void>(); + + const udpSocket = createSocket("udp4"); + udpSocket.bind(listenPort); + + udpSocket.unref(); + udpSocket.ref(); + + let data; + udpSocket.on("message", (buffer, _rinfo) => { + data = Uint8Array.from(buffer); + udpSocket.close(); + }); + udpSocket.on("close", () => { + resolve(); + }); + + const conn = await Deno.listenDatagram({ + port: listenPort2, + transport: "udp", + }); + await conn.send(new Uint8Array([0, 1, 2, 3]), { + transport: "udp", + port: listenPort, + hostname: "127.0.0.1", + }); + + await promise; + conn.close(); + assertEquals(data, new Uint8Array([0, 1, 2, 3])); +}); + +Deno.test("[node/dgram] udp unref", { + permissions: { read: true, run: true, net: true }, +}, async () => { + const [statusCode, _output] = await execCode(` + import { createSocket } from "node:dgram"; + const udpSocket = createSocket('udp4'); + udpSocket.bind(${listenPort2}); + // This should let the program to exit without waiting for the + // udp socket to close. + udpSocket.unref(); + udpSocket.on('message', (buffer, rinfo) => { + }); + `); + assertEquals(statusCode, 0); +}); diff --git a/tests/unit_node/events_test.ts b/tests/unit_node/events_test.ts new file mode 100644 index 000000000..13abf5f79 --- /dev/null +++ b/tests/unit_node/events_test.ts @@ -0,0 +1,27 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import { EventEmitter } from "node:events"; + +EventEmitter.captureRejections = true; + +Deno.test("regression #20441", async () => { + const { promise, resolve } = Promise.withResolvers<void>(); + + const ee = new EventEmitter(); + + ee.on("foo", function () { + const p = new Promise((_resolve, reject) => { + setTimeout(() => { + reject(); + }, 100); + }); + return p; + }); + + ee.on("error", function (_) { + resolve(); + }); + + ee.emit("foo"); + await promise; +}); diff --git a/tests/unit_node/fs_test.ts b/tests/unit_node/fs_test.ts new file mode 100644 index 000000000..e0cdf3a23 --- /dev/null +++ b/tests/unit_node/fs_test.ts @@ -0,0 +1,116 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import { + assert, + assertEquals, + assertThrows, +} from "@test_util/std/assert/mod.ts"; +import { join } from "node:path"; +import { tmpdir } from "node:os"; +import { + constants, + existsSync, + mkdtempSync, + promises, + readFileSync, + writeFileSync, +} from "node:fs"; +import { constants as fsPromiseConstants, cp } from "node:fs/promises"; +import { pathToAbsoluteFileUrl } from "../unit/test_util.ts"; + +Deno.test( + "[node/fs writeFileSync] write file without option", + () => { + const data = "Hello"; + const filename = mkdtempSync(join(tmpdir(), "foo-")) + "/test.txt"; + + writeFileSync(filename, data); + const dataRead = readFileSync(filename, "utf8"); + + assert(dataRead === "Hello"); + }, +); + +Deno.test( + "[node/fs writeFileSync] write file with option ASCII", + () => { + const data = "Hello"; + const filename = mkdtempSync(join(tmpdir(), "foo-")) + "/test.txt"; + + writeFileSync(filename, data, { encoding: "ascii" }); + const dataRead = readFileSync(filename, "utf8"); + + assert(dataRead === "Hello"); + }, +); + +Deno.test( + "[node/fs writeFileSync] write file throws error when encoding is not implemented", + () => { + const data = "Hello"; + const filename = mkdtempSync(join(tmpdir(), "foo-")) + "/test.txt"; + + assertThrows( + () => writeFileSync(filename, data, { encoding: "utf16le" }), + 'The value "utf16le" is invalid for option "encoding"', + ); + }, +); + +Deno.test( + "[node/fs existsSync] path", + { permissions: { read: true } }, + () => { + assert(existsSync("tests/testdata/assets/fixture.json")); + }, +); + +Deno.test( + "[node/fs existsSync] url", + { permissions: { read: true } }, + () => { + assert(existsSync( + pathToAbsoluteFileUrl("tests/testdata/assets/fixture.json"), + )); + }, +); + +Deno.test( + "[node/fs existsSync] no permission", + { permissions: { read: false } }, + () => { + assertThrows(() => { + existsSync("tests/testdata/assets/fixture.json"); + }, Deno.errors.PermissionDenied); + }, +); + +Deno.test( + "[node/fs existsSync] not exists", + { permissions: { read: true } }, + () => { + assert(!existsSync("bad_filename")); + }, +); + +Deno.test( + "[node/fs/promises constants] is the same as from node:fs", + () => { + assertEquals(constants, fsPromiseConstants); + assertEquals(constants, promises.constants); + }, +); + +Deno.test( + "[node/fs/promises cp] copy file", + async () => { + const src = mkdtempSync(join(tmpdir(), "foo-")) + "/test.txt"; + const dest = mkdtempSync(join(tmpdir(), "foo-")) + "/test.txt"; + writeFileSync(src, "Hello"); + + await cp(src, dest); + + const dataRead = readFileSync(dest, "utf8"); + assert(dataRead === "Hello"); + }, +); diff --git a/tests/unit_node/http2_test.ts b/tests/unit_node/http2_test.ts new file mode 100644 index 000000000..5db5cc8e8 --- /dev/null +++ b/tests/unit_node/http2_test.ts @@ -0,0 +1,138 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import * as http2 from "node:http2"; +import * as net from "node:net"; +import { assertEquals } from "@test_util/std/assert/mod.ts"; + +for (const url of ["http://127.0.0.1:4246", "https://127.0.0.1:4247"]) { + Deno.test(`[node/http2 client] ${url}`, { + ignore: Deno.build.os === "windows", + }, async () => { + // Create a server to respond to the HTTP2 requests + const client = http2.connect(url, {}); + client.on("error", (err) => console.error(err)); + + const req = client.request({ ":method": "POST", ":path": "/" }, { + waitForTrailers: true, + }); + + let receivedTrailers; + let receivedHeaders; + let receivedData = ""; + + req.on("response", (headers, _flags) => { + receivedHeaders = headers; + }); + + req.write("hello"); + req.setEncoding("utf8"); + + req.on("wantTrailers", () => { + req.sendTrailers({ foo: "bar" }); + }); + + req.on("trailers", (trailers, _flags) => { + receivedTrailers = trailers; + }); + + req.on("data", (chunk) => { + receivedData += chunk; + }); + req.end(); + + const { promise, resolve } = Promise.withResolvers<void>(); + setTimeout(() => { + try { + client.close(); + } catch (_) { + // pass + } + resolve(); + }, 2000); + + await promise; + assertEquals(receivedHeaders, { ":status": 200 }); + assertEquals(receivedData, "hello world\n"); + + assertEquals(receivedTrailers, { + "abc": "def", + "opr": "stv", + "foo": "bar", + }); + }); +} + +Deno.test(`[node/http2 client createConnection]`, { + ignore: Deno.build.os === "windows", +}, async () => { + const url = "http://127.0.0.1:4246"; + const createConnDeferred = Promise.withResolvers<void>(); + // Create a server to respond to the HTTP2 requests + const client = http2.connect(url, { + createConnection() { + const socket = net.connect({ host: "127.0.0.1", port: 4246 }); + + socket.on("connect", () => { + createConnDeferred.resolve(); + }); + + return socket; + }, + }); + client.on("error", (err) => console.error(err)); + + const req = client.request({ ":method": "POST", ":path": "/" }); + + let receivedData = ""; + + req.write("hello"); + req.setEncoding("utf8"); + + req.on("data", (chunk) => { + receivedData += chunk; + }); + req.end(); + + const endPromise = Promise.withResolvers<void>(); + setTimeout(() => { + try { + client.close(); + } catch (_) { + // pass + } + endPromise.resolve(); + }, 2000); + + await createConnDeferred.promise; + await endPromise.promise; + assertEquals(receivedData, "hello world\n"); +}); + +// TODO(bartlomieju): reenable sanitizers +Deno.test("[node/http2 server]", { sanitizeOps: false }, async () => { + const server = http2.createServer(); + server.listen(0); + const port = (<net.AddressInfo> server.address()).port; + const sessionPromise = new Promise<http2.Http2Session>((resolve) => + server.on("session", resolve) + ); + + const responsePromise = fetch(`http://localhost:${port}/path`, { + method: "POST", + body: "body", + }); + + const session = await sessionPromise; + const stream = await new Promise<http2.ServerHttp2Stream>((resolve) => + session.on("stream", resolve) + ); + await new Promise((resolve) => stream.on("headers", resolve)); + await new Promise((resolve) => stream.on("data", resolve)); + await new Promise((resolve) => stream.on("end", resolve)); + stream.respond(); + stream.end(); + const resp = await responsePromise; + await resp.text(); + + await new Promise((resolve) => server.close(resolve)); +}); diff --git a/tests/unit_node/http_test.ts b/tests/unit_node/http_test.ts new file mode 100644 index 000000000..28e67ddad --- /dev/null +++ b/tests/unit_node/http_test.ts @@ -0,0 +1,940 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import EventEmitter from "node:events"; +import http, { type RequestOptions } from "node:http"; +import https from "node:https"; +import { assert, assertEquals, fail } from "@test_util/std/assert/mod.ts"; +import { assertSpyCalls, spy } from "@test_util/std/testing/mock.ts"; + +import { gzip } from "node:zlib"; +import { Buffer } from "node:buffer"; +import { serve } from "@test_util/std/http/server.ts"; +import { execCode } from "../unit/test_util.ts"; + +Deno.test("[node/http listen]", async () => { + { + const server = http.createServer(); + assertEquals(0, EventEmitter.listenerCount(server, "request")); + } + + { + const server = http.createServer(() => {}); + assertEquals(1, EventEmitter.listenerCount(server, "request")); + } + + { + const { promise, resolve } = Promise.withResolvers<void>(); + const server = http.createServer(); + + server.listen(() => { + server.close(); + }); + server.on("close", () => { + resolve(); + }); + + await promise; + } + + { + const { promise, resolve } = Promise.withResolvers<void>(); + const server = http.createServer(); + + server.listen().on("listening", () => { + server.close(); + }); + server.on("close", () => { + resolve(); + }); + + await promise; + } + + for (const port of [0, -0, 0.0, "0", null, undefined]) { + const { promise, resolve } = Promise.withResolvers<void>(); + const server = http.createServer(); + + server.listen(port, () => { + server.close(); + }); + server.on("close", () => { + resolve(); + }); + + await promise; + } +}); + +Deno.test("[node/http close]", async () => { + { + const deferred1 = Promise.withResolvers<void>(); + const deferred2 = Promise.withResolvers<void>(); + // Node quirk: callback gets exception object, event listener does not. + // deno-lint-ignore no-explicit-any + const server = http.createServer().close((err: any) => { + assertEquals(err.code, "ERR_SERVER_NOT_RUNNING"); + deferred1.resolve(); + }); + // deno-lint-ignore no-explicit-any + server.on("close", (err: any) => { + assertEquals(err, undefined); + deferred2.resolve(); + }); + server.on("listening", () => { + throw Error("unreachable"); + }); + await deferred1.promise; + await deferred2.promise; + } + + { + const deferred1 = Promise.withResolvers<void>(); + const deferred2 = Promise.withResolvers<void>(); + const server = http.createServer().listen().close((err) => { + assertEquals(err, undefined); + deferred1.resolve(); + }); + // deno-lint-ignore no-explicit-any + server.on("close", (err: any) => { + assertEquals(err, undefined); + deferred2.resolve(); + }); + server.on("listening", () => { + throw Error("unreachable"); + }); + await deferred1.promise; + await deferred2.promise; + } +}); + +Deno.test("[node/http] chunked response", async () => { + for ( + const body of [undefined, "", "ok"] + ) { + const expected = body ?? ""; + const { promise, resolve } = Promise.withResolvers<void>(); + + const server = http.createServer((_req, res) => { + res.writeHead(200, { "transfer-encoding": "chunked" }); + res.end(body); + }); + + server.listen(async () => { + const res = await fetch( + // deno-lint-ignore no-explicit-any + `http://127.0.0.1:${(server.address() as any).port}/`, + ); + assert(res.ok); + + const actual = await res.text(); + assertEquals(actual, expected); + + server.close(() => resolve()); + }); + + await promise; + } +}); + +// Test empty chunks: https://github.com/denoland/deno/issues/17194 +Deno.test("[node/http] empty chunk in the middle of response", async () => { + const { promise, resolve } = Promise.withResolvers<void>(); + + const server = http.createServer((_req, res) => { + res.write("a"); + res.write(""); + res.write("b"); + res.end(); + }); + + server.listen(async () => { + const res = await fetch( + // deno-lint-ignore no-explicit-any + `http://127.0.0.1:${(server.address() as any).port}/`, + ); + const actual = await res.text(); + assertEquals(actual, "ab"); + server.close(() => resolve()); + }); + + await promise; +}); + +Deno.test("[node/http] server can respond with 101, 204, 205, 304 status", async () => { + for (const status of [101, 204, 205, 304]) { + const { promise, resolve } = Promise.withResolvers<void>(); + const server = http.createServer((_req, res) => { + res.statusCode = status; + res.end(""); + }); + server.listen(async () => { + const res = await fetch( + // deno-lint-ignore no-explicit-any + `http://127.0.0.1:${(server.address() as any).port}/`, + ); + await res.arrayBuffer(); + assertEquals(res.status, status); + server.close(() => resolve()); + }); + await promise; + } +}); + +Deno.test("[node/http] IncomingRequest socket has remoteAddress + remotePort", async () => { + const { promise, resolve } = Promise.withResolvers<void>(); + + let remoteAddress: string | undefined; + let remotePort: number | undefined; + const server = http.createServer((req, res) => { + remoteAddress = req.socket.remoteAddress; + remotePort = req.socket.remotePort; + res.end(); + }); + server.listen(async () => { + // deno-lint-ignore no-explicit-any + const port = (server.address() as any).port; + const res = await fetch( + `http://127.0.0.1:${port}/`, + ); + await res.arrayBuffer(); + assertEquals(remoteAddress, "127.0.0.1"); + assertEquals(typeof remotePort, "number"); + server.close(() => resolve()); + }); + await promise; +}); + +Deno.test("[node/http] request default protocol", async () => { + const deferred1 = Promise.withResolvers<void>(); + const deferred2 = Promise.withResolvers<void>(); + const server = http.createServer((_, res) => { + res.end("ok"); + }); + + // @ts-ignore IncomingMessageForClient + // deno-lint-ignore no-explicit-any + let clientRes: any; + // deno-lint-ignore no-explicit-any + let clientReq: any; + server.listen(() => { + clientReq = http.request( + // deno-lint-ignore no-explicit-any + { host: "localhost", port: (server.address() as any).port }, + (res) => { + assert(res.socket instanceof EventEmitter); + assertEquals(res.complete, false); + res.on("data", () => {}); + res.on("end", () => { + server.close(); + }); + clientRes = res; + assertEquals(res.statusCode, 200); + deferred2.resolve(); + }, + ); + clientReq.end(); + }); + server.on("close", () => { + deferred1.resolve(); + }); + await deferred1.promise; + await deferred2.promise; + assert(clientReq.socket instanceof EventEmitter); + assertEquals(clientRes!.complete, true); +}); + +Deno.test("[node/http] request with headers", async () => { + const { promise, resolve } = Promise.withResolvers<void>(); + const server = http.createServer((req, res) => { + assertEquals(req.headers["x-foo"], "bar"); + res.end("ok"); + }); + server.listen(() => { + const req = http.request( + { + host: "localhost", + // deno-lint-ignore no-explicit-any + port: (server.address() as any).port, + headers: { "x-foo": "bar" }, + }, + (res) => { + res.on("data", () => {}); + res.on("end", () => { + server.close(); + }); + assertEquals(res.statusCode, 200); + }, + ); + req.end(); + }); + server.on("close", () => { + resolve(); + }); + await promise; +}); + +Deno.test("[node/http] non-string buffer response", { + // TODO(kt3k): Enable sanitizer. A "zlib" resource is leaked in this test case. + sanitizeResources: false, +}, async () => { + const { promise, resolve } = Promise.withResolvers<void>(); + const server = http.createServer((_, res) => { + res.socket!.end(); + gzip( + Buffer.from("a".repeat(100), "utf8"), + {}, + (_err: Error | null, data: Buffer) => { + res.setHeader("Content-Encoding", "gzip"); + res.end(data); + }, + ); + }); + server.listen(async () => { + const res = await fetch( + // deno-lint-ignore no-explicit-any + `http://localhost:${(server.address() as any).port}`, + ); + try { + const text = await res.text(); + assertEquals(text, "a".repeat(100)); + } catch (e) { + server.emit("error", e); + } finally { + server.close(() => resolve()); + } + }); + await promise; +}); + +// TODO(kt3k): Enable this test +// Currently IncomingMessage constructor has incompatible signature. +/* +Deno.test("[node/http] http.IncomingMessage can be created without url", () => { + const message = new http.IncomingMessage( + // adapted from https://github.com/dougmoscrop/serverless-http/blob/80bfb3e940057d694874a8b0bc12ad96d2abe7ab/lib/request.js#L7 + { + // @ts-expect-error - non-request properties will also be passed in, e.g. by serverless-http + encrypted: true, + readable: false, + remoteAddress: "foo", + address: () => ({ port: 443 }), + // deno-lint-ignore no-explicit-any + end: Function.prototype as any, + // deno-lint-ignore no-explicit-any + destroy: Function.prototype as any, + }, + ); + message.url = "https://example.com"; +}); +*/ + +Deno.test("[node/http] send request with non-chunked body", async () => { + let requestHeaders: Headers; + let requestBody = ""; + + const hostname = "localhost"; + const port = 4505; + + // NOTE: Instead of node/http.createServer(), serve() in std/http/server.ts is used. + // https://github.com/denoland/deno_std/pull/2755#discussion_r1005592634 + const handler = async (req: Request) => { + requestHeaders = req.headers; + requestBody = await req.text(); + return new Response("ok"); + }; + const abortController = new AbortController(); + const servePromise = serve(handler, { + hostname, + port, + signal: abortController.signal, + onListen: undefined, + }); + + const opts: RequestOptions = { + host: hostname, + port, + method: "POST", + headers: { + "Content-Type": "text/plain; charset=utf-8", + "Content-Length": "11", + }, + }; + const req = http.request(opts, (res) => { + res.on("data", () => {}); + res.on("end", () => { + abortController.abort(); + }); + assertEquals(res.statusCode, 200); + assertEquals(requestHeaders.get("content-length"), "11"); + assertEquals(requestHeaders.has("transfer-encoding"), false); + assertEquals(requestBody, "hello world"); + }); + req.on("socket", (socket) => { + assert(socket.writable); + assert(socket.readable); + socket.setKeepAlive(); + socket.destroy(); + socket.setTimeout(100); + }); + req.write("hello "); + req.write("world"); + req.end(); + + await servePromise; +}); + +Deno.test("[node/http] send request with chunked body", async () => { + let requestHeaders: Headers; + let requestBody = ""; + + const hostname = "localhost"; + const port = 4505; + + // NOTE: Instead of node/http.createServer(), serve() in std/http/server.ts is used. + // https://github.com/denoland/deno_std/pull/2755#discussion_r1005592634 + const handler = async (req: Request) => { + requestHeaders = req.headers; + requestBody = await req.text(); + return new Response("ok"); + }; + const abortController = new AbortController(); + const servePromise = serve(handler, { + hostname, + port, + signal: abortController.signal, + onListen: undefined, + }); + + const opts: RequestOptions = { + host: hostname, + port, + method: "POST", + headers: { + "Content-Type": "text/plain; charset=utf-8", + "Content-Length": "11", + "Transfer-Encoding": "chunked", + }, + }; + const req = http.request(opts, (res) => { + res.on("data", () => {}); + res.on("end", () => { + abortController.abort(); + }); + assertEquals(res.statusCode, 200); + assertEquals(requestHeaders.has("content-length"), false); + assertEquals(requestHeaders.get("transfer-encoding"), "chunked"); + assertEquals(requestBody, "hello world"); + }); + req.write("hello "); + req.write("world"); + req.end(); + + await servePromise; +}); + +Deno.test("[node/http] send request with chunked body as default", async () => { + let requestHeaders: Headers; + let requestBody = ""; + + const hostname = "localhost"; + const port = 4505; + + // NOTE: Instead of node/http.createServer(), serve() in std/http/server.ts is used. + // https://github.com/denoland/deno_std/pull/2755#discussion_r1005592634 + const handler = async (req: Request) => { + requestHeaders = req.headers; + requestBody = await req.text(); + return new Response("ok"); + }; + const abortController = new AbortController(); + const servePromise = serve(handler, { + hostname, + port, + signal: abortController.signal, + onListen: undefined, + }); + + const opts: RequestOptions = { + host: hostname, + port, + method: "POST", + headers: { + "Content-Type": "text/plain; charset=utf-8", + }, + }; + const req = http.request(opts, (res) => { + res.on("data", () => {}); + res.on("end", () => { + abortController.abort(); + }); + assertEquals(res.statusCode, 200); + assertEquals(requestHeaders.has("content-length"), false); + assertEquals(requestHeaders.get("transfer-encoding"), "chunked"); + assertEquals(requestBody, "hello world"); + }); + req.write("hello "); + req.write("world"); + req.end(); + + await servePromise; +}); + +Deno.test("[node/http] ServerResponse _implicitHeader", async () => { + const { promise, resolve } = Promise.withResolvers<void>(); + const server = http.createServer((_req, res) => { + const writeHeadSpy = spy(res, "writeHead"); + // deno-lint-ignore no-explicit-any + (res as any)._implicitHeader(); + assertSpyCalls(writeHeadSpy, 1); + writeHeadSpy.restore(); + res.end("Hello World"); + }); + + server.listen(async () => { + const { port } = server.address() as { port: number }; + const res = await fetch(`http://localhost:${port}`); + assertEquals(await res.text(), "Hello World"); + server.close(() => { + resolve(); + }); + }); + + await promise; +}); + +// https://github.com/denoland/deno/issues/21509 +Deno.test("[node/http] ServerResponse flushHeaders", async () => { + const { promise, resolve } = Promise.withResolvers<void>(); + const server = http.createServer((_req, res) => { + res.flushHeaders(); // no-op + res.end("Hello World"); + }); + + server.listen(async () => { + const { port } = server.address() as { port: number }; + const res = await fetch(`http://localhost:${port}`); + assertEquals(await res.text(), "Hello World"); + server.close(() => { + resolve(); + }); + }); + + await promise; +}); + +Deno.test("[node/http] server unref", async () => { + const [statusCode, _output] = await execCode(` + import http from "node:http"; + const server = http.createServer((_req, res) => { + res.statusCode = status; + res.end(""); + }); + + // This should let the program to exit without waiting for the + // server to close. + server.unref(); + + server.listen(async () => { + }); + `); + assertEquals(statusCode, 0); +}); + +Deno.test("[node/http] ClientRequest handle non-string headers", async () => { + // deno-lint-ignore no-explicit-any + let headers: any; + const { promise, resolve, reject } = Promise.withResolvers<void>(); + const req = http.request("http://localhost:4545/echo_server", { + method: "POST", + headers: { 1: 2 }, + }, (resp) => { + headers = resp.headers; + + resp.on("data", () => {}); + + resp.on("end", () => { + resolve(); + }); + }); + req.once("error", (e) => reject(e)); + req.end(); + await promise; + assertEquals(headers!["1"], "2"); +}); + +Deno.test("[node/http] ClientRequest uses HTTP/1.1", async () => { + let body = ""; + const { promise, resolve, reject } = Promise.withResolvers<void>(); + const req = https.request("https://localhost:5545/http_version", { + method: "POST", + headers: { 1: 2 }, + }, (resp) => { + resp.on("data", (chunk) => { + body += chunk; + }); + + resp.on("end", () => { + resolve(); + }); + }); + req.once("error", (e) => reject(e)); + req.end(); + await promise; + assertEquals(body, "HTTP/1.1"); +}); + +Deno.test("[node/http] ClientRequest setTimeout", async () => { + let body = ""; + const { promise, resolve, reject } = Promise.withResolvers<void>(); + const timer = setTimeout(() => reject("timed out"), 50000); + const req = http.request("http://localhost:4545/http_version", (resp) => { + resp.on("data", (chunk) => { + body += chunk; + }); + + resp.on("end", () => { + resolve(); + }); + }); + req.setTimeout(120000); + req.once("error", (e) => reject(e)); + req.end(); + await promise; + clearTimeout(timer); + assertEquals(body, "HTTP/1.1"); +}); + +Deno.test("[node/http] ClientRequest setNoDelay", async () => { + let body = ""; + const { promise, resolve, reject } = Promise.withResolvers<void>(); + const timer = setTimeout(() => reject("timed out"), 50000); + const req = http.request("http://localhost:4545/http_version", (resp) => { + resp.on("data", (chunk) => { + body += chunk; + }); + + resp.on("end", () => { + resolve(); + }); + }); + req.setNoDelay(true); + req.once("error", (e) => reject(e)); + req.end(); + await promise; + clearTimeout(timer); + assertEquals(body, "HTTP/1.1"); +}); + +Deno.test("[node/http] ClientRequest PATCH", async () => { + let body = ""; + const { promise, resolve, reject } = Promise.withResolvers<void>(); + const req = http.request("http://localhost:4545/echo_server", { + method: "PATCH", + }, (resp) => { + resp.on("data", (chunk) => { + body += chunk; + }); + + resp.on("end", () => { + resolve(); + }); + }); + req.write("hello "); + req.write("world"); + req.once("error", (e) => reject(e)); + req.end(); + await promise; + assertEquals(body, "hello world"); +}); + +Deno.test("[node/http] ClientRequest PUT", async () => { + let body = ""; + const { promise, resolve, reject } = Promise.withResolvers<void>(); + const req = http.request("http://localhost:4545/echo_server", { + method: "PUT", + }, (resp) => { + resp.on("data", (chunk) => { + body += chunk; + }); + + resp.on("end", () => { + resolve(); + }); + }); + req.write("hello "); + req.write("world"); + req.once("error", (e) => reject(e)); + req.end(); + await promise; + assertEquals(body, "hello world"); +}); + +Deno.test("[node/http] ClientRequest search params", async () => { + let body = ""; + const { promise, resolve, reject } = Promise.withResolvers<void>(); + const req = http.request({ + host: "localhost:4545", + path: "search_params?foo=bar", + }, (resp) => { + resp.on("data", (chunk) => { + body += chunk; + }); + + resp.on("end", () => { + resolve(); + }); + }); + req.once("error", (e) => reject(e)); + req.end(); + await promise; + assertEquals(body, "foo=bar"); +}); + +Deno.test("[node/http] HTTPS server", async () => { + const deferred = Promise.withResolvers<void>(); + const deferred2 = Promise.withResolvers<void>(); + const client = Deno.createHttpClient({ + caCerts: [Deno.readTextFileSync("tests/testdata/tls/RootCA.pem")], + }); + const server = https.createServer({ + cert: Deno.readTextFileSync("tests/testdata/tls/localhost.crt"), + key: Deno.readTextFileSync("tests/testdata/tls/localhost.key"), + }, (req, res) => { + // @ts-ignore: It exists on TLSSocket + assert(req.socket.encrypted); + res.end("success!"); + }); + server.listen(() => { + // deno-lint-ignore no-explicit-any + fetch(`https://localhost:${(server.address() as any).port}`, { + client, + }).then(async (res) => { + assertEquals(res.status, 200); + assertEquals(await res.text(), "success!"); + server.close(); + deferred2.resolve(); + }); + }) + .on("error", () => fail()); + server.on("close", () => { + deferred.resolve(); + }); + await Promise.all([deferred.promise, deferred2.promise]); + client.close(); +}); + +Deno.test( + "[node/http] client upgrade", + { permissions: { net: true } }, + async () => { + const { promise, resolve } = Promise.withResolvers<void>(); + const server = http.createServer((req, res) => { + // @ts-ignore: It exists on TLSSocket + assert(!req.socket.encrypted); + res.writeHead(200, { "Content-Type": "text/plain" }); + res.end("okay"); + }); + // @ts-ignore it's a socket for real + let serverSocket; + server.on("upgrade", (req, socket, _head) => { + // https://github.com/denoland/deno/issues/21979 + assert(req.socket?.write); + socket.write( + "HTTP/1.1 101 Web Socket Protocol Handshake\r\n" + + "Upgrade: WebSocket\r\n" + + "Connection: Upgrade\r\n" + + "\r\n", + ); + serverSocket = socket; + }); + + // Now that server is running + server.listen(1337, "127.0.0.1", () => { + // make a request + const options = { + port: 1337, + host: "127.0.0.1", + headers: { + "Connection": "Upgrade", + "Upgrade": "websocket", + }, + }; + + const req = http.request(options); + req.end(); + + req.on("upgrade", (_res, socket, _upgradeHead) => { + socket.end(); + // @ts-ignore it's a socket for real + serverSocket!.end(); + server.close(() => { + resolve(); + }); + }); + }); + + await promise; + }, +); + +Deno.test( + "[node/http] client end with callback", + { permissions: { net: true } }, + async () => { + let received = false; + const ac = new AbortController(); + const server = Deno.serve({ port: 5928, signal: ac.signal }, (_req) => { + received = true; + return new Response("hello"); + }); + const { promise, resolve, reject } = Promise.withResolvers<void>(); + let body = ""; + + const request = http.request( + "http://localhost:5928/", + (resp) => { + resp.on("data", (chunk) => { + body += chunk; + }); + + resp.on("end", () => { + resolve(); + }); + }, + ); + request.on("error", reject); + request.end(() => { + assert(received); + }); + + await promise; + ac.abort(); + await server.finished; + + assertEquals(body, "hello"); + }, +); + +Deno.test("[node/http] server emits error if addr in use", async () => { + const deferred1 = Promise.withResolvers<void>(); + const deferred2 = Promise.withResolvers<Error>(); + + const server = http.createServer(); + server.listen(9001); + + const server2 = http.createServer(); + server2.on("error", (e) => { + deferred2.resolve(e); + }); + server2.listen(9001); + + const err = await deferred2.promise; + server.close(() => deferred1.resolve()); + server2.close(); + await deferred1.promise; + const expectedMsg = Deno.build.os === "windows" + ? "Only one usage of each socket address" + : "Address already in use"; + assert( + err.message.startsWith(expectedMsg), + `Wrong error: ${err.message}`, + ); +}); + +Deno.test( + "[node/http] client destroy doesn't leak", + { permissions: { net: true } }, + async () => { + const ac = new AbortController(); + let timerId; + + const server = Deno.serve( + { port: 5929, signal: ac.signal }, + async (_req) => { + await new Promise((resolve) => { + timerId = setTimeout(resolve, 5000); + }); + return new Response("hello"); + }, + ); + const { promise, resolve, reject } = Promise.withResolvers<void>(); + + const request = http.request("http://localhost:5929/"); + request.on("error", reject); + request.on("close", () => {}); + request.end(); + setTimeout(() => { + request.destroy(new Error()); + resolve(); + }, 100); + + await promise; + clearTimeout(timerId); + ac.abort(); + await server.finished; + }, +); + +Deno.test("[node/http] node:http exports globalAgent", async () => { + const http = await import("node:http"); + assert( + http.globalAgent, + "node:http must export 'globalAgent' on module namespace", + ); + assert( + http.default.globalAgent, + "node:http must export 'globalAgent' on module default export", + ); +}); + +Deno.test("[node/https] node:https exports globalAgent", async () => { + const https = await import("node:https"); + assert( + https.globalAgent, + "node:https must export 'globalAgent' on module namespace", + ); + assert( + https.default.globalAgent, + "node:https must export 'globalAgent' on module default export", + ); +}); + +Deno.test("[node/http] node:http request.setHeader(header, null) doesn't throw", () => { + { + const req = http.request("http://localhost:4545/"); + req.on("error", () => {}); + // @ts-expect-error - null is not a valid header value + req.setHeader("foo", null); + req.end(); + req.destroy(); + } + { + const req = https.request("https://localhost:4545/"); + req.on("error", () => {}); + // @ts-expect-error - null is not a valid header value + req.setHeader("foo", null); + req.end(); + req.destroy(); + } +}); + +Deno.test("[node/http] ServerResponse getHeader", async () => { + const { promise, resolve } = Promise.withResolvers<void>(); + const server = http.createServer((_req, res) => { + res.setHeader("foo", "bar"); + assertEquals(res.getHeader("foo"), "bar"); + assertEquals(res.getHeader("ligma"), undefined); + res.end("Hello World"); + }); + + server.listen(async () => { + const { port } = server.address() as { port: number }; + const res = await fetch(`http://localhost:${port}`); + assertEquals(await res.text(), "Hello World"); + server.close(() => { + resolve(); + }); + }); + + await promise; +}); diff --git a/tests/unit_node/internal/_randomBytes_test.ts b/tests/unit_node/internal/_randomBytes_test.ts new file mode 100644 index 000000000..13ee82566 --- /dev/null +++ b/tests/unit_node/internal/_randomBytes_test.ts @@ -0,0 +1,112 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { + assert, + assertEquals, + assertRejects, + assertThrows, +} from "@test_util/std/assert/mod.ts"; +import { assertCallbackErrorUncaught } from "../_test_utils.ts"; +import { pseudoRandomBytes, randomBytes } from "node:crypto"; + +const MAX_RANDOM_VALUES = 65536; +const MAX_SIZE = 4294967295; + +Deno.test("randomBytes sync works correctly", function () { + assertEquals(randomBytes(0).length, 0, "len: " + 0); + assertEquals(randomBytes(3).length, 3, "len: " + 3); + assertEquals(randomBytes(30).length, 30, "len: " + 30); + assertEquals(randomBytes(300).length, 300, "len: " + 300); + assertEquals( + randomBytes(17 + MAX_RANDOM_VALUES).length, + 17 + MAX_RANDOM_VALUES, + "len: " + 17 + MAX_RANDOM_VALUES, + ); + assertEquals( + randomBytes(MAX_RANDOM_VALUES * 100).length, + MAX_RANDOM_VALUES * 100, + "len: " + MAX_RANDOM_VALUES * 100, + ); + assertThrows(() => randomBytes(MAX_SIZE + 1)); + assertThrows(() => randomBytes(-1)); +}); + +Deno.test("randomBytes async works correctly", async function () { + randomBytes(0, function (err, resp) { + assert(!err); + assertEquals(resp?.length, 0, "len: " + 0); + }); + randomBytes(3, function (err, resp) { + assert(!err); + assertEquals(resp?.length, 3, "len: " + 3); + }); + randomBytes(30, function (err, resp) { + assert(!err); + assertEquals(resp?.length, 30, "len: " + 30); + }); + randomBytes(300, function (err, resp) { + assert(!err); + assertEquals(resp?.length, 300, "len: " + 300); + }); + randomBytes(17 + MAX_RANDOM_VALUES, function (err, resp) { + assert(!err); + assertEquals( + resp?.length, + 17 + MAX_RANDOM_VALUES, + "len: " + 17 + MAX_RANDOM_VALUES, + ); + }); + randomBytes(MAX_RANDOM_VALUES * 100, function (err, resp) { + assert(!err); + assertEquals( + resp?.length, + MAX_RANDOM_VALUES * 100, + "len: " + MAX_RANDOM_VALUES * 100, + ); + }); + assertThrows(() => + randomBytes(MAX_SIZE + 1, function (err) { + //Shouldn't throw async + assert(!err); + }) + ); + await assertRejects(() => + new Promise((resolve, reject) => { + randomBytes(-1, function (err, res) { + //Shouldn't throw async + if (err) { + reject(err); + } else { + resolve(res); + } + }); + }) + ); +}); + +Deno.test("[std/node/crypto] randomBytes callback isn't called twice if error is thrown", async () => { + const importUrl = new URL("node:crypto", import.meta.url); + await assertCallbackErrorUncaught({ + prelude: `import { randomBytes } from ${JSON.stringify(importUrl)}`, + invocation: "randomBytes(0, ", + }); +}); + +// https://github.com/denoland/deno/issues/21632 +Deno.test("pseudoRandomBytes works", function () { + assertEquals(pseudoRandomBytes(0).length, 0, "len: " + 0); + assertEquals(pseudoRandomBytes(3).length, 3, "len: " + 3); + assertEquals(pseudoRandomBytes(30).length, 30, "len: " + 30); + assertEquals(pseudoRandomBytes(300).length, 300, "len: " + 300); + assertEquals( + pseudoRandomBytes(17 + MAX_RANDOM_VALUES).length, + 17 + MAX_RANDOM_VALUES, + "len: " + 17 + MAX_RANDOM_VALUES, + ); + assertEquals( + pseudoRandomBytes(MAX_RANDOM_VALUES * 100).length, + MAX_RANDOM_VALUES * 100, + "len: " + MAX_RANDOM_VALUES * 100, + ); + assertThrows(() => pseudoRandomBytes(MAX_SIZE + 1)); + assertThrows(() => pseudoRandomBytes(-1)); +}); diff --git a/tests/unit_node/internal/_randomFill_test.ts b/tests/unit_node/internal/_randomFill_test.ts new file mode 100644 index 000000000..d85569960 --- /dev/null +++ b/tests/unit_node/internal/_randomFill_test.ts @@ -0,0 +1,65 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { Buffer } from "node:buffer"; +import { randomFill, randomFillSync } from "node:crypto"; +import { + assertEquals, + assertNotEquals, + assertThrows, +} from "@test_util/std/assert/mod.ts"; + +const validateNonZero = (buf: Buffer) => { + if (!buf.some((ch) => ch > 0)) throw new Error("Error"); +}; + +const validateZero = (buf: Buffer) => { + buf.forEach((val) => assertEquals(val, 0)); +}; + +Deno.test("[node/crypto.randomFill]", async () => { + const { promise, resolve } = Promise.withResolvers<boolean>(); + const buf = Buffer.alloc(10); + const before = buf.toString("hex"); + + randomFill(buf, 5, 5, (_err, bufTwo) => { + const after = bufTwo?.toString("hex"); + assertEquals(before.slice(0, 10), after?.slice(0, 10)); + resolve(true); + }); + + await promise; +}); + +Deno.test("[node/crypto.randomFillSync]", () => { + const buf = Buffer.alloc(10); + const before = buf.toString("hex"); + + const after = randomFillSync(buf, 5, 5); + + assertNotEquals(before, after.toString("hex")); +}); + +Deno.test("[node/crypto.randomFillSync] Complete fill, explicit size", () => { + const buf = Buffer.alloc(10); + randomFillSync(buf, undefined, 10); + validateNonZero(buf); +}); + +Deno.test("[randomFillSync] Complete fill", () => { + const buf = Buffer.alloc(10); + randomFillSync(buf); + validateNonZero(buf); +}); + +Deno.test("[node/crypto.randomFillSync] Fill beginning, explicit offset+size", () => { + const buf = Buffer.alloc(10); + randomFillSync(buf, 0, 5); + validateNonZero(buf); + + const untouched = buf.slice(5); + assertEquals(untouched.length, 5); + validateZero(untouched); +}); + +Deno.test("[node/crypto.randomFillSync] Invalid offst/size", () => { + assertThrows(() => randomFillSync(Buffer.alloc(10), 1, 10)); +}); diff --git a/tests/unit_node/internal/_randomInt_test.ts b/tests/unit_node/internal/_randomInt_test.ts new file mode 100644 index 000000000..2639f77ce --- /dev/null +++ b/tests/unit_node/internal/_randomInt_test.ts @@ -0,0 +1,32 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { randomInt } from "node:crypto"; +import { assert, assertThrows } from "@test_util/std/assert/mod.ts"; + +const between = (x: number, min: number, max: number) => x >= min && x < max; + +Deno.test("[node/crypto.randomInt] One Param: Max", () => { + assert(between(randomInt(55), 0, 55)); +}); + +Deno.test("[node/crypto.randomInt] Two Params: Max and Min", () => { + assert(between(randomInt(40, 120), 40, 120)); +}); + +Deno.test("[node/crypto.randomInt] Max and Callback", () => { + let called = false; + randomInt(3, (_err, val) => { + called = true; + assert(between(val as number, 0, 3)); + }); + assert(called); +}); + +Deno.test("[node/crypto.randomInt] Min, Max and Callback", () => { + randomInt(3, 5, (_err, val) => { + assert(between(val as number, 3, 5)); + }); +}); + +Deno.test("[node/crypto.randomInt] Min is bigger than Max", () => { + assertThrows(() => randomInt(45, 34)); +}); diff --git a/tests/unit_node/internal/pbkdf2_test.ts b/tests/unit_node/internal/pbkdf2_test.ts new file mode 100644 index 000000000..019e76dcd --- /dev/null +++ b/tests/unit_node/internal/pbkdf2_test.ts @@ -0,0 +1,387 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { pbkdf2, pbkdf2Sync } from "node:crypto"; +import { assert, assertEquals } from "@test_util/std/assert/mod.ts"; + +type Algorithms = + | "md5" + | "ripemd160" + | "sha1" + | "sha224" + | "sha256" + | "sha384" + | "sha512"; + +type Pbkdf2Fixture = { + key: string | Float64Array | Int32Array | Uint8Array; + salt: string | Float64Array | Int32Array | Uint8Array; + iterations: number; + dkLen: number; + results: { [key in Algorithms]: string }; +}; + +const fixtures: Pbkdf2Fixture[] = [ + { + "key": "password", + "salt": "salt", + "iterations": 1, + "dkLen": 32, + "results": { + "md5": "f31afb6d931392daa5e3130f47f9a9b6e8e72029d8350b9fb27a9e0e00b9d991", + "sha1": + "0c60c80f961f0e71f3a9b524af6012062fe037a6e0f0eb94fe8fc46bdc637164", + "sha256": + "120fb6cffcf8b32c43e7225256c4f837a86548c92ccc35480805987cb70be17b", + "sha512": + "867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252", + "sha224": + "3c198cbdb9464b7857966bd05b7bc92bc1cc4e6e63155d4e490557fd85989497", + "sha384": + "c0e14f06e49e32d73f9f52ddf1d0c5c7191609233631dadd76a567db42b78676", + "ripemd160": + "b725258b125e0bacb0e2307e34feb16a4d0d6aed6cb4b0eee458fc1829020428", + }, + }, + { + "key": "password", + "salt": "salt", + "iterations": 2, + "dkLen": 32, + "results": { + "md5": "042407b552be345ad6eee2cf2f7ed01dd9662d8f0c6950eaec7124aa0c82279e", + "sha1": + "ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957cae93136266537a8d7bf4b76", + "sha256": + "ae4d0c95af6b46d32d0adff928f06dd02a303f8ef3c251dfd6e2d85a95474c43", + "sha512": + "e1d9c16aa681708a45f5c7c4e215ceb66e011a2e9f0040713f18aefdb866d53c", + "sha224": + "93200ffa96c5776d38fa10abdf8f5bfc0054b9718513df472d2331d2d1e66a3f", + "sha384": + "54f775c6d790f21930459162fc535dbf04a939185127016a04176a0730c6f1f4", + "ripemd160": + "768dcc27b7bfdef794a1ff9d935090fcf598555e66913180b9ce363c615e9ed9", + }, + }, + { + "key": "password", + "salt": "salt", + "iterations": 1, + "dkLen": 64, + "results": { + "md5": + "f31afb6d931392daa5e3130f47f9a9b6e8e72029d8350b9fb27a9e0e00b9d9915a5f18928639ca8bbc3d1c1cb66d4f27b9dfe39156774c6798b42adc57ed253f", + "sha1": + "0c60c80f961f0e71f3a9b524af6012062fe037a6e0f0eb94fe8fc46bdc637164ac2e7a8e3f9d2e83ace57e0d50e5e1071367c179bc86c767fc3f78ddb561363f", + "sha256": + "120fb6cffcf8b32c43e7225256c4f837a86548c92ccc35480805987cb70be17b4dbf3a2f3dad3377264bb7b8e8330d4efc7451418617dabef683735361cdc18c", + "sha512": + "867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252c02d470a285a0501bad999bfe943c08f050235d7d68b1da55e63f73b60a57fce", + "sha224": + "3c198cbdb9464b7857966bd05b7bc92bc1cc4e6e63155d4e490557fd859894978ab846d52a1083ac610c36c2c5ea8ce4a024dd691064d5453bd17b15ea1ac194", + "sha384": + "c0e14f06e49e32d73f9f52ddf1d0c5c7191609233631dadd76a567db42b78676b38fc800cc53ddb642f5c74442e62be44d727702213e3bb9223c53b767fbfb5d", + "ripemd160": + "b725258b125e0bacb0e2307e34feb16a4d0d6aed6cb4b0eee458fc18290204289e55d962783bf52237d264cbbab25f18d89d8c798f90f558ea7b45bdf3d08334", + }, + }, + { + "key": "password", + "salt": "salt", + "iterations": 2, + "dkLen": 64, + "results": { + "md5": + "042407b552be345ad6eee2cf2f7ed01dd9662d8f0c6950eaec7124aa0c82279ed0b7e2a854d0f29ec82ddcabe9760368e5821af8745d74846ccbd17afbfe5ff0", + "sha1": + "ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957cae93136266537a8d7bf4b76c51094cc1ae010b19923ddc4395cd064acb023ffd1edd5ef4be8ffe61426c28e", + "sha256": + "ae4d0c95af6b46d32d0adff928f06dd02a303f8ef3c251dfd6e2d85a95474c43830651afcb5c862f0b249bd031f7a67520d136470f5ec271ece91c07773253d9", + "sha512": + "e1d9c16aa681708a45f5c7c4e215ceb66e011a2e9f0040713f18aefdb866d53cf76cab2868a39b9f7840edce4fef5a82be67335c77a6068e04112754f27ccf4e", + "sha224": + "93200ffa96c5776d38fa10abdf8f5bfc0054b9718513df472d2331d2d1e66a3f97b510224f700ce72581ffb10a1c99ec99a8cc1b951851a71f30d9265fccf912", + "sha384": + "54f775c6d790f21930459162fc535dbf04a939185127016a04176a0730c6f1f4fb48832ad1261baadd2cedd50814b1c806ad1bbf43ebdc9d047904bf7ceafe1e", + "ripemd160": + "768dcc27b7bfdef794a1ff9d935090fcf598555e66913180b9ce363c615e9ed953b95fd07169be535e38afbea29c030e06d14f40745b1513b7ccdf0e76229e50", + }, + }, + { + "key": "63ffeeddccbbaa", + "salt": "salt", + "iterations": 1, + "dkLen": 32, + "results": { + "md5": "23a33e38c9c57ea122df372a5b96347667e843ba21c79f150ce503d947449b75", + "sha1": + "1a12b21aa46bd3bed3a23b8ad072a1465585344b1516252618aabbc41276dada", + "sha256": + "a47c9371d4d4f663c2a0d3becbd475b7eb884722c7265391381d7696151470a6", + "sha512": + "09328469e02fcee4f6ab88a23037de33d54f17f786eee39e1f8826109ee54e16", + "sha224": + "59baceb002865e57061c65dd861c309c049a97207054416c943764efc38b94ed", + "sha384": + "01cc52b81eda47c8bc9861ab7f7de682e92a0d5e522f4d3a06a3b97be1856580", + "ripemd160": + "4f04f4782f2def250005e04ef0497403330b52a085ae856f4640700b19983b7c", + }, + }, + { + "key": + "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about", + "salt": + "6d6e656d6f6e6963e383a1e383bce38388e383abe382abe38299e3838fe38299e382a6e38299e382a1e381afe3829ae381afe38299e3818fe38299e3829de38299e381a1e381a1e38299e58d81e4babae58d81e889b2", + "iterations": 2048, + "dkLen": 64, + "results": { + "md5": + "029d0e4484f56d9cf7ab7ca972c8991aeb2be275cba9683db4143e9b72f67d49551ec4c70ca6d051538fc7a86b8568d08244fdea24ba826b7927babac4f62cf2", + "sha1": + "fb3fa7c05a98ff66da2eadd69fa2ba52401ee630e04322d3c5bb018d1dda03c7e47bdea0c9e4c77c87826632eed59bbe42ce05329a838664683b1a8dae3fffd8", + "sha256": + "3b19907cb907d1ee6e5a0ecb80bd66e2776d1f2c73f4789eafcad94fda832e970471ceb0d200ede70e63ae021044cf4b58b1011e34252ace8d94a48c287906ec", + "sha512": + "0be4563c5175fd02b042251228774f34c1ccb235054a9f0f968c6d828466eae8c32433a7aa09ce922722dc808c6a1629ba8f1b6ba46f0cf7a921e125d1cc9fcd", + "sha224": + "dd529ad11b298cafad9209a0a620af98cf1b782bd0ba1a61efcd74a4fe2662af6c36ffd015c68ed0cd630bdb023ea61e59317eb07b342e0c6ece1bd3034b768c", + "sha384": + "7265c090b602b0a432b4908f70b6a5a2a6657926d09ac72ebb78d8bcc81e0d4563316f1eb5570b2850ef06a14719746a8a8397d3d56aa51b2d50489741b7ff61", + "ripemd160": + "c984beaf664aea5ae7f671063ef2ad1f80098e48382a916809ff9212d1a8cb7ad6cb17354422717c668726dfce294e1442bb354b6a6693db84032172e77af6ae", + }, + }, + { + "key": "password", + "salt": "salt", + "iterations": 1, + "dkLen": 10, + "results": { + "md5": "f31afb6d931392daa5e3", + "sha1": "0c60c80f961f0e71f3a9", + "sha256": "120fb6cffcf8b32c43e7", + "sha512": "867f70cf1ade02cff375", + "sha224": "3c198cbdb9464b785796", + "sha384": "c0e14f06e49e32d73f9f", + "ripemd160": "b725258b125e0bacb0e2", + }, + }, + { + "key": "password", + "salt": "salt", + "iterations": 1, + "dkLen": 100, + "results": { + "md5": + "f31afb6d931392daa5e3130f47f9a9b6e8e72029d8350b9fb27a9e0e00b9d9915a5f18928639ca8bbc3d1c1cb66d4f27b9dfe39156774c6798b42adc57ed253f44fc731edccf067904ce2e317b9ef45767add4dfe53f8c190dac43d90cda5e66e627d4f2", + "sha1": + "0c60c80f961f0e71f3a9b524af6012062fe037a6e0f0eb94fe8fc46bdc637164ac2e7a8e3f9d2e83ace57e0d50e5e1071367c179bc86c767fc3f78ddb561363fc692ba406d1301e42bcccc3c520d06751d78b80c3db926b16ffa3395bd697c647f280b51", + "sha256": + "120fb6cffcf8b32c43e7225256c4f837a86548c92ccc35480805987cb70be17b4dbf3a2f3dad3377264bb7b8e8330d4efc7451418617dabef683735361cdc18c22cd7fe60fa40e91c65849e1f60c0d8b62a7b2dbd0d3dfd75fb8498a5c2131ab02b66de5", + "sha512": + "867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252c02d470a285a0501bad999bfe943c08f050235d7d68b1da55e63f73b60a57fce7b532e206c2967d4c7d2ffa460539fc4d4e5eec70125d74c6c7cf86d25284f297907fcea", + "sha224": + "3c198cbdb9464b7857966bd05b7bc92bc1cc4e6e63155d4e490557fd859894978ab846d52a1083ac610c36c2c5ea8ce4a024dd691064d5453bd17b15ea1ac1944bbfd62e61b997e7b22660f588e297186572480015f33bc2bfd2b423827bcdcdb4845914", + "sha384": + "c0e14f06e49e32d73f9f52ddf1d0c5c7191609233631dadd76a567db42b78676b38fc800cc53ddb642f5c74442e62be44d727702213e3bb9223c53b767fbfb5db9d270d54c45d9cb6003d2967280b22671e2dbc6375f6ebf219c36f0d127be35e19d65a8", + "ripemd160": + "b725258b125e0bacb0e2307e34feb16a4d0d6aed6cb4b0eee458fc18290204289e55d962783bf52237d264cbbab25f18d89d8c798f90f558ea7b45bdf3d083340c18b9d23ba842183c5364d18bc0ffde5a8a408dd7ef02dde561a08d21c6d2325a69869b", + }, + }, + { + "key": new Uint8Array([112, 97, 115, 115, 119, 111, 114, 100]), + "salt": "salt", + "iterations": 1, + "dkLen": 32, + "results": { + "md5": "f31afb6d931392daa5e3130f47f9a9b6e8e72029d8350b9fb27a9e0e00b9d991", + "sha1": + "0c60c80f961f0e71f3a9b524af6012062fe037a6e0f0eb94fe8fc46bdc637164", + "sha256": + "120fb6cffcf8b32c43e7225256c4f837a86548c92ccc35480805987cb70be17b", + "sha512": + "867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252", + "sha224": + "3c198cbdb9464b7857966bd05b7bc92bc1cc4e6e63155d4e490557fd85989497", + "sha384": + "c0e14f06e49e32d73f9f52ddf1d0c5c7191609233631dadd76a567db42b78676", + "ripemd160": + "b725258b125e0bacb0e2307e34feb16a4d0d6aed6cb4b0eee458fc1829020428", + }, + }, + { + "key": "password", + "salt": new Uint8Array([115, 97, 108, 116]), + "iterations": 1, + "dkLen": 32, + "results": { + "md5": "f31afb6d931392daa5e3130f47f9a9b6e8e72029d8350b9fb27a9e0e00b9d991", + "sha1": + "0c60c80f961f0e71f3a9b524af6012062fe037a6e0f0eb94fe8fc46bdc637164", + "sha256": + "120fb6cffcf8b32c43e7225256c4f837a86548c92ccc35480805987cb70be17b", + "sha512": + "867f70cf1ade02cff3752599a3a53dc4af34c7a669815ae5d513554e1c8cf252", + "sha224": + "3c198cbdb9464b7857966bd05b7bc92bc1cc4e6e63155d4e490557fd85989497", + "sha384": + "c0e14f06e49e32d73f9f52ddf1d0c5c7191609233631dadd76a567db42b78676", + "ripemd160": + "b725258b125e0bacb0e2307e34feb16a4d0d6aed6cb4b0eee458fc1829020428", + }, + }, + { + "key": new Int32Array([112, 97, 115, 115, 119, 111, 114, 100]), + "salt": "salt", + "iterations": 1, + "dkLen": 32, + "results": { + "md5": "81de8e85b07d7969d9fe530641b63cc4ecbbf2345037cdc0ba61ad329fc7029c", + "sha1": + "f260ccd0bbc8fe6773119b834feec48636b716caad4180a4d0af4f9aa67c646e", + "sha256": + "9b4608f5eeab348f0b9d85a918b140706b24f275acf6829382dfee491015f9eb", + "sha512": + "c44b8f26550fe6ca0a55bce54b4a75e9530398f32ec28b59d0fded996e95e3d5", + "sha224": + "03d0c2b530ec6339e6418cb0f906e50591619be40aa8817aa9c7305d1773231c", + "sha384": + "2e69d62ae8c21ebc2de45a885b488f65fb88dfa58aaa9c57dd1fcb9d1edce96a", + "ripemd160": + "fc69276ba3f145492065feb0259b9edf68179f2023c95094e71ac7d01748018a", + }, + }, + { + "key": "password", + "salt": new Int32Array([115, 97, 108, 116]), + "iterations": 1, + "dkLen": 32, + "results": { + "md5": "36587a57770a8eef264391786b4ddfae0723f6a64dc2fc199fe7eb6ad9def701", + "sha1": + "b297f1ea23008f10ba9d645961e4661109e804b10af26bea22c44244492d6252", + "sha256": + "f678f0772894c079f21377d9ee1e76dd77b62dfc1f0575e6aa9eb030af7a356a", + "sha512": + "7f8133f6937ae1d7e4a43c19aabd2de8308d5b833341281716a501334cdb2470", + "sha224": + "ab66d29d3dacc731e44f091a7baa051926219cf493e8b9e3934cedfb215adc8b", + "sha384": + "cf139d648cf63e9b85a3b9b8f23f4445b84d22201bc2544bc273a17d5dcb7b28", + "ripemd160": + "26142e48fae1ad1c53be54823aadda2aa7d42f5524463fb1eff0efafa08edb9d", + }, + }, + { + "key": new Float64Array([112, 97, 115, 115, 119, 111, 114, 100]), + "salt": "salt", + "iterations": 1, + "dkLen": 32, + "results": { + "md5": "48336072da7d11ff203c61705b384b1c60953e7d1677fed2cd3e65738d60e67e", + "sha1": + "c2b17a7e98cc48690a92cd9f753a2c700229045905167571aa281aafe8230bba", + "sha256": + "55d62579a083a6c14b886710f81b54f567d214d343af776e5e90c467ea81b821", + "sha512": + "ded01ce343e2683d962fc74b7b5ceef525228f49393ce9353254f44e3dc7e9aa", + "sha224": + "5f10a348d320c7555b972b8d7d45a363a91e1a82dea063c3ac495cfad74a8d89", + "sha384": + "4b7f97dbadfd652e0579499d0e23607ec476ed4bea9d6f1740d0b110e2d08792", + "ripemd160": + "f92080d972a649d98d91a53922863fc7b8076c54869e9885f9a804868ef752e0", + }, + }, + { + "key": "password", + "salt": new Float64Array([115, 97, 108, 116]), + "iterations": 1, + "dkLen": 32, + "results": { + "md5": "9f1716e6f9d77b0beb56758f9509edea50828d15909073c3c715f66173ac3716", + "sha1": + "f158b9edd28c16ad3b41e0e8197ec132a98c2ddea73b959f55ec9792e0b29d6f", + "sha256": + "a6154d17480547a10212f75883509842f88f2ca5d6c1a2419646e47342051852", + "sha512": + "b10c2ea742de7dd0525988761ee1733564c91380eeaa1b199f4fafcbf7144b0c", + "sha224": + "29b315ac30c7d5e1640ca0f9e27b68a794fb9f950b8dd117129824f103ffb9db", + "sha384": + "624b4ed6ad389b976fb7503e54a35109f249c29ac6eb8b56850152be21b3cb0e", + "ripemd160": + "8999b9280207bc9c76cf25327aa352da26a683fac7a2adff17a39dcc4f4c3b5b", + }, + }, +]; + +Deno.test("pbkdf2 hashes data correctly", async () => { + const promises: Promise<void>[] = []; + fixtures.forEach(({ + dkLen, + iterations, + key, + results, + salt, + }) => { + for (const algorithm in results) { + if (Object.hasOwn(results, algorithm)) { + promises.push( + new Promise((resolve, reject) => { + pbkdf2( + key, + salt, + iterations, + dkLen, + algorithm as Algorithms, + (err, res) => { + try { + assert(!err, String(err)); + assertEquals( + res?.toString("hex"), + results[algorithm as Algorithms], + ); + resolve(); + } catch (e) { + reject(e); + } + }, + ); + }), + ); + } + } + }); + + await Promise.all(promises); +}); + +Deno.test("pbkdf2Sync hashes data correctly", () => { + fixtures.forEach(({ + dkLen, + iterations, + key, + results, + salt, + }) => { + for (const algorithm in results) { + if (Object.hasOwn(results, algorithm)) { + assertEquals( + pbkdf2Sync(key, salt, iterations, dkLen, algorithm as Algorithms) + .toString("hex"), + results[algorithm as Algorithms], + ); + } + } + }); +}); + +// TODO(@littledivy): assertCallbackErrorUncaught exits for async operations on the thread pool. +// Deno.test("[std/node/crypto] pbkdf2 callback isn't called twice if error is thrown", async () => { +// const importUrl = new URL("node:crypto", import.meta.url); +// await assertCallbackErrorUncaught({ +// prelude: `import { pbkdf2 } from ${JSON.stringify(importUrl)};`, +// invocation: 'pbkdf2("password", "salt", 1, 32, "sha1", ', +// }); +// }); diff --git a/tests/unit_node/internal/scrypt_test.ts b/tests/unit_node/internal/scrypt_test.ts new file mode 100644 index 000000000..bd846ba8d --- /dev/null +++ b/tests/unit_node/internal/scrypt_test.ts @@ -0,0 +1,190 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { scrypt, scryptSync } from "node:crypto"; +import { Buffer } from "node:buffer"; +import { assertEquals } from "@test_util/std/assert/mod.ts"; + +Deno.test("scrypt works correctly", async () => { + const { promise, resolve } = Promise.withResolvers<boolean>(); + + scrypt("password", "salt", 32, (err, key) => { + if (err) throw err; + assertEquals( + key, + Buffer.from([ + 116, + 87, + 49, + 175, + 68, + 132, + 243, + 35, + 150, + 137, + 105, + 237, + 162, + 137, + 174, + 238, + 0, + 91, + 89, + 3, + 172, + 86, + 30, + 100, + 165, + 172, + 161, + 33, + 121, + 123, + 247, + 115, + ]), + ); + resolve(true); + }); + + await promise; +}); + +Deno.test("scrypt works with options", async () => { + const { promise, resolve } = Promise.withResolvers<boolean>(); + + scrypt( + "password", + "salt", + 32, + { + N: 512, + }, + (err, key) => { + if (err) throw err; + assertEquals( + key, + Buffer.from([ + 57, + 134, + 165, + 72, + 236, + 9, + 166, + 182, + 42, + 46, + 138, + 230, + 251, + 154, + 25, + 15, + 214, + 209, + 57, + 208, + 31, + 163, + 203, + 87, + 251, + 42, + 144, + 179, + 98, + 92, + 193, + 71, + ]), + ); + resolve(true); + }, + ); + + await promise; +}); + +Deno.test("scryptSync works correctly", () => { + const key = scryptSync("password", "salt", 32); + assertEquals( + key, + Buffer.from([ + 116, + 87, + 49, + 175, + 68, + 132, + 243, + 35, + 150, + 137, + 105, + 237, + 162, + 137, + 174, + 238, + 0, + 91, + 89, + 3, + 172, + 86, + 30, + 100, + 165, + 172, + 161, + 33, + 121, + 123, + 247, + 115, + ]), + ); +}); + +Deno.test("scryptSync with options works correctly", () => { + const key = scryptSync("password", "salt", 32, { N: 512 }); + assertEquals( + key, + Buffer.from([ + 57, + 134, + 165, + 72, + 236, + 9, + 166, + 182, + 42, + 46, + 138, + 230, + 251, + 154, + 25, + 15, + 214, + 209, + 57, + 208, + 31, + 163, + 203, + 87, + 251, + 42, + 144, + 179, + 98, + 92, + 193, + 71, + ]), + ); +}); diff --git a/tests/unit_node/module_test.ts b/tests/unit_node/module_test.ts new file mode 100644 index 000000000..f8e117254 --- /dev/null +++ b/tests/unit_node/module_test.ts @@ -0,0 +1,72 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import { createRequire, Module } from "node:module"; +import { assert, assertEquals } from "@test_util/std/assert/mod.ts"; +import process from "node:process"; +import * as path from "node:path"; + +Deno.test("[node/module _preloadModules] has internal require hook", () => { + // Check if it's there + // deno-lint-ignore no-explicit-any + (Module as any)._preloadModules([ + "./tests/unit_node/testdata/add_global_property.js", + ]); + // deno-lint-ignore no-explicit-any + assertEquals((globalThis as any).foo, "Hello"); +}); + +Deno.test("[node/module runMain] loads module using the current process.argv", () => { + process.argv = [ + process.argv[0], + "./tests/unit_node/testdata/add_global_property_run_main.js", + ]; + + // deno-lint-ignore no-explicit-any + (Module as any).runMain(); + // deno-lint-ignore no-explicit-any + assertEquals((globalThis as any).calledViaRunMain, true); +}); + +Deno.test("[node/module _nodeModulePaths] prevents duplicate /node_modules/node_modules suffix", () => { + // deno-lint-ignore no-explicit-any + const actual: string[] = (Module as any)._nodeModulePaths( + path.join(process.cwd(), "testdata", "node_modules", "foo"), + ); + + assert( + !actual.some((dir) => /node_modules[/\\]node_modules/g.test(dir)), + "Duplicate 'node_modules/node_modules' suffix found", + ); +}); + +Deno.test("[node/module _nodeModulePaths] prevents duplicate root /node_modules", () => { + // deno-lint-ignore no-explicit-any + const actual: string[] = (Module as any)._nodeModulePaths( + path.join(process.cwd(), "testdata", "node_modules", "foo"), + ); + + assert( + new Set(actual).size === actual.length, + "Duplicate path entries found", + ); + const root = path.parse(actual[0]).root; + assert( + actual.includes(path.join(root, "node_modules")), + "Missing root 'node_modules' directory", + ); +}); + +Deno.test("Built-in Node modules have `node:` prefix", () => { + let thrown = false; + try { + // @ts-ignore We want to explicitly test wrong call signature + createRequire(); + } catch (e) { + thrown = true; + const stackLines = e.stack.split("\n"); + // Assert that built-in node modules have `node:<mod_name>` specifiers. + assert(stackLines.some((line: string) => line.includes("(node:module:"))); + } + + assert(thrown); +}); diff --git a/tests/unit_node/net_test.ts b/tests/unit_node/net_test.ts new file mode 100644 index 000000000..60cf9d8fc --- /dev/null +++ b/tests/unit_node/net_test.ts @@ -0,0 +1,201 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import * as net from "node:net"; +import { assert, assertEquals } from "@test_util/std/assert/mod.ts"; +import * as path from "@test_util/std/path/mod.ts"; +import * as http from "node:http"; + +Deno.test("[node/net] close event emits after error event", async () => { + const socket = net.createConnection(27009, "doesnotexist"); + const events: ("error" | "close")[] = []; + const errorEmitted = Promise.withResolvers<void>(); + const closeEmitted = Promise.withResolvers<void>(); + socket.once("error", () => { + events.push("error"); + errorEmitted.resolve(); + }); + socket.once("close", () => { + events.push("close"); + closeEmitted.resolve(); + }); + await Promise.all([errorEmitted.promise, closeEmitted.promise]); + + // `error` happens before `close` + assertEquals(events, ["error", "close"]); +}); + +Deno.test("[node/net] the port is available immediately after close callback", async () => { + const deferred = Promise.withResolvers<void>(); + + // This simulates what get-port@5.1.1 does. + const getAvailablePort = (port: number) => + new Promise((resolve, reject) => { + const server = net.createServer(); + server.on("error", reject); + server.listen({ port }, () => { + // deno-lint-ignore no-explicit-any + const { port } = server.address() as any; + server.close(() => { + resolve(port); + }); + }); + }); + + const port = await getAvailablePort(5555); + + const httpServer = http.createServer(); + httpServer.on("error", (e) => deferred.reject(e)); + httpServer.listen(port, () => { + httpServer.close(() => deferred.resolve()); + }); + await deferred.promise; +}); + +Deno.test("[node/net] net.connect().unref() works", async () => { + const ctl = new AbortController(); + const server = Deno.serve({ + signal: ctl.signal, + handler: () => new Response("hello"), + onListen: async ({ port, hostname }) => { + const { stdout, stderr } = await new Deno.Command(Deno.execPath(), { + args: [ + "eval", + ` + import * as net from "node:net"; + const socket = net.connect(${port}, "${hostname}", () => { + console.log("connected"); + socket.unref(); + socket.on("data", (data) => console.log(data.toString())); + socket.write("GET / HTTP/1.1\\n\\n"); + }); + `, + ], + cwd: path.dirname(path.fromFileUrl(import.meta.url)), + }).output(); + if (stderr.length > 0) { + console.log(new TextDecoder().decode(stderr)); + } + assertEquals(new TextDecoder().decode(stdout), "connected\n"); + ctl.abort(); + }, + }); + await server.finished; +}); + +Deno.test({ + name: "[node/net] throws permission error instead of unknown error", + permissions: "none", + fn: () => { + try { + const s = new net.Server(); + s.listen(3000); + } catch (e) { + assert(e instanceof Deno.errors.PermissionDenied); + } + }, +}); + +Deno.test("[node/net] connection event has socket value", async () => { + const deferred = Promise.withResolvers<void>(); + const deferred2 = Promise.withResolvers<void>(); + + const server = net.createServer(); + server.on("error", deferred.reject); + server.on("connection", (socket) => { + assert(socket !== undefined); + socket.end(); + server.close(() => { + deferred.resolve(); + }); + }); + server.listen(async () => { + // deno-lint-ignore no-explicit-any + const { port } = server.address() as any; + + const conn = await Deno.connect({ + port, + transport: "tcp", + }); + + for await (const _ of conn.readable) { + // + } + + deferred2.resolve(); + }); + + await Promise.all([deferred.promise, deferred2.promise]); +}); + +/// We need to make sure that any shared buffers are never used concurrently by two reads. +// https://github.com/denoland/deno/issues/20188 +Deno.test("[node/net] multiple Sockets should get correct server data", async () => { + const socketCount = 9; + + class TestSocket { + dataReceived: ReturnType<typeof Promise.withResolvers<void>> = Promise + .withResolvers<void>(); + events: string[] = []; + socket: net.Socket | undefined; + } + + const finished = Promise.withResolvers<void>(); + const serverSocketsClosed: ReturnType<typeof Promise.withResolvers<void>>[] = + []; + const server = net.createServer(); + server.on("connection", (socket) => { + assert(socket !== undefined); + const i = serverSocketsClosed.push(Promise.withResolvers<void>()); + socket.on("data", (data) => { + socket.write(new TextDecoder().decode(data)); + }); + socket.on("close", () => { + serverSocketsClosed[i - 1].resolve(); + }); + }); + + const sockets: TestSocket[] = []; + for (let i = 0; i < socketCount; i++) { + sockets[i] = new TestSocket(); + } + + server.listen(async () => { + // deno-lint-ignore no-explicit-any + const { port } = server.address() as any; + + for (let i = 0; i < socketCount; i++) { + const socket = sockets[i].socket = net.createConnection(port); + socket.on("data", (data) => { + const count = sockets[i].events.length; + sockets[i].events.push(new TextDecoder().decode(data)); + if (count === 0) { + // Trigger an immediate second write + sockets[i].socket?.write(`${i}`.repeat(3)); + } else { + sockets[i].dataReceived.resolve(); + } + }); + } + + for (let i = 0; i < socketCount; i++) { + sockets[i].socket?.write(`${i}`.repeat(3)); + } + + await Promise.all(sockets.map((socket) => socket.dataReceived.promise)); + + for (let i = 0; i < socketCount; i++) { + sockets[i].socket?.end(); + } + + server.close(() => { + finished.resolve(); + }); + }); + + await finished.promise; + await Promise.all(serverSocketsClosed.map(({ promise }) => promise)); + + for (let i = 0; i < socketCount; i++) { + assertEquals(sockets[i].events, [`${i}`.repeat(3), `${i}`.repeat(3)]); + } +}); diff --git a/tests/unit_node/os_test.ts b/tests/unit_node/os_test.ts new file mode 100644 index 000000000..c18aa07c3 --- /dev/null +++ b/tests/unit_node/os_test.ts @@ -0,0 +1,325 @@ +// deno-lint-ignore-file no-undef +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import os from "node:os"; +import { + assert, + assertEquals, + assertNotEquals, + assertThrows, +} from "@test_util/std/assert/mod.ts"; + +Deno.test({ + name: "build architecture is a string", + fn() { + assertEquals(typeof os.arch(), "string"); + }, +}); + +Deno.test({ + name: "build architecture", + fn() { + if (Deno.build.arch == "x86_64") { + assertEquals(os.arch(), "x64"); + } else if (Deno.build.arch == "aarch64") { + assertEquals(os.arch(), "arm64"); + } else { + throw new Error("unreachable"); + } + }, +}); + +Deno.test({ + name: "os machine (arch)", + fn() { + if (Deno.build.arch == "aarch64") { + assertEquals(os.machine(), "arm64"); + } else { + assertEquals(os.machine(), Deno.build.arch); + } + }, +}); + +Deno.test({ + name: "home directory is a string", + fn() { + assertEquals(typeof os.homedir(), "string"); + }, +}); + +Deno.test({ + name: "tmp directory is a string", + fn() { + assertEquals(typeof os.tmpdir(), "string"); + }, +}); + +Deno.test({ + name: "hostname is a string", + fn() { + assertEquals(typeof os.hostname(), "string"); + }, +}); + +Deno.test({ + name: "platform is a string", + fn() { + assertEquals(typeof os.platform(), "string"); + }, +}); + +Deno.test({ + name: "release is a string", + fn() { + assertEquals(typeof os.release(), "string"); + }, +}); + +Deno.test({ + name: "type is a string", + fn() { + assertEquals(typeof os.type(), "string"); + }, +}); + +Deno.test({ + name: "getPriority(): PID must be a 32 bit integer", + fn() { + assertThrows( + () => { + os.getPriority(3.15); + }, + Error, + "pid must be 'an integer'", + ); + assertThrows( + () => { + os.getPriority(9999999999); + }, + Error, + "must be >= -2147483648 && <= 2147483647", + ); + }, +}); + +Deno.test({ + name: "setPriority(): PID must be a 32 bit integer", + fn() { + assertThrows( + () => { + os.setPriority(3.15, 0); + }, + Error, + "pid must be 'an integer'", + ); + assertThrows( + () => { + os.setPriority(9999999999, 0); + }, + Error, + "pid must be >= -2147483648 && <= 2147483647", + ); + }, +}); + +Deno.test({ + name: "setPriority(): priority must be an integer between -20 and 19", + fn() { + assertThrows( + () => { + os.setPriority(0, 3.15); + }, + Error, + "priority must be 'an integer'", + ); + assertThrows( + () => { + os.setPriority(0, -21); + }, + Error, + "priority must be >= -20 && <= 19", + ); + assertThrows( + () => { + os.setPriority(0, 20); + }, + Error, + "priority must be >= -20 && <= 19", + ); + assertThrows( + () => { + os.setPriority(0, 9999999999); + }, + Error, + "priority must be >= -20 && <= 19", + ); + }, +}); + +Deno.test({ + name: + "setPriority(): if only one argument specified, then this is the priority, NOT the pid", + fn() { + assertThrows( + () => { + os.setPriority(3.15); + }, + Error, + "priority must be 'an integer'", + ); + assertThrows( + () => { + os.setPriority(-21); + }, + Error, + "priority must be >= -20 && <= 19", + ); + assertThrows( + () => { + os.setPriority(20); + }, + Error, + "priority must be >= -20 && <= 19", + ); + assertThrows( + () => { + os.setPriority(9999999999); + }, + Error, + "priority must be >= -20 && <= 19", + ); + }, +}); + +Deno.test({ + name: "EOL is as expected", + fn() { + assert(os.EOL == "\r\n" || os.EOL == "\n"); + }, +}); + +Deno.test({ + name: "Endianness is determined", + fn() { + assert(["LE", "BE"].includes(os.endianness())); + }, +}); + +Deno.test({ + name: "Load average is an array of 3 numbers", + fn() { + const result = os.loadavg(); + assert(result.length == 3); + assertEquals(typeof result[0], "number"); + assertEquals(typeof result[1], "number"); + assertEquals(typeof result[2], "number"); + }, +}); + +Deno.test({ + name: "Primitive coercion works as expected", + fn() { + assertEquals(`${os.arch}`, os.arch()); + assertEquals(`${os.endianness}`, os.endianness()); + assertEquals(`${os.platform}`, os.platform()); + }, +}); + +Deno.test({ + name: "Total memory amount should be greater than 0", + fn() { + assert(os.totalmem() > 0); + }, +}); + +Deno.test({ + name: "Free memory amount should be greater than 0", + fn() { + assert(os.freemem() > 0); + }, +}); + +Deno.test({ + name: "Uptime should be greater than 0", + fn() { + assert(os.uptime() > 0); + }, +}); + +Deno.test({ + name: "os.cpus()", + fn() { + assertEquals(os.cpus().length, navigator.hardwareConcurrency); + + for (const cpu of os.cpus()) { + assert(cpu.model.length > 0); + assert(cpu.speed >= 0); + assert(cpu.times.user > 0); + assert(cpu.times.sys > 0); + assert(cpu.times.idle > 0); + } + }, +}); + +Deno.test({ + name: "os.setPriority() & os.getPriority()", + // disabled because os.getPriority() doesn't work without sudo + ignore: true, + fn() { + const child = new Deno.Command(Deno.execPath(), { + args: ["eval", "while (true) { console.log('foo') }"], + }).spawn(); + const originalPriority = os.getPriority(child.pid); + assertNotEquals(originalPriority, os.constants.priority.PRIORITY_HIGH); + os.setPriority(child.pid, os.constants.priority.PRIORITY_HIGH); + assertEquals( + os.getPriority(child.pid), + os.constants.priority.PRIORITY_HIGH, + ); + os.setPriority(child.pid, originalPriority); + assertEquals(os.getPriority(child.pid), originalPriority); + child.kill(); + }, +}); + +Deno.test({ + name: + "os.setPriority() throw os permission denied error & os.getPriority() doesn't", + async fn() { + const child = new Deno.Command(Deno.execPath(), { + args: ["eval", "while (true) { console.log('foo') }"], + }).spawn(); + assertThrows( + () => os.setPriority(child.pid, os.constants.priority.PRIORITY_HIGH), + Deno.errors.PermissionDenied, + ); + os.getPriority(child.pid); + child.kill(); + await child.status; + }, +}); + +// Gets the diff in log_10 scale +function diffLog10(a: number, b: number): number { + return Math.abs(Math.log10(a) - Math.log10(b)); +} + +Deno.test({ + name: + "os.freemem() is equivalent of Deno.systemMemoryInfo().free except on linux", + ignore: Deno.build.os === "linux", + fn() { + const diff = diffLog10(os.freemem(), Deno.systemMemoryInfo().free); + assert(diff < 1); + }, +}); + +Deno.test({ + name: + "os.freemem() is equivalent of Deno.systemMemoryInfo().available on linux", + ignore: Deno.build.os !== "linux", + fn() { + const diff = diffLog10(os.freemem(), Deno.systemMemoryInfo().available); + assert(diff < 1); + }, +}); diff --git a/tests/unit_node/path_test.ts b/tests/unit_node/path_test.ts new file mode 100644 index 000000000..a6c4ec5a8 --- /dev/null +++ b/tests/unit_node/path_test.ts @@ -0,0 +1,16 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import path from "node:path"; +import posix from "node:path/posix"; +import win32 from "node:path/win32"; + +import { assertStrictEquals } from "@test_util/std/assert/mod.ts"; + +Deno.test("[node/path] posix and win32 objects", () => { + assertStrictEquals(path.posix, posix); + assertStrictEquals(path.win32, win32); + assertStrictEquals(path.posix, path.posix.posix); + assertStrictEquals(path.win32, path.posix.win32); + assertStrictEquals(path.posix, path.win32.posix); + assertStrictEquals(path.win32, path.win32.win32); +}); diff --git a/tests/unit_node/perf_hooks_test.ts b/tests/unit_node/perf_hooks_test.ts new file mode 100644 index 000000000..004eedfd6 --- /dev/null +++ b/tests/unit_node/perf_hooks_test.ts @@ -0,0 +1,62 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import * as perfHooks from "node:perf_hooks"; +import { performance } from "node:perf_hooks"; +import { assertEquals, assertThrows } from "@test_util/std/assert/mod.ts"; + +Deno.test({ + name: "[perf_hooks] performance", + fn() { + assertEquals(perfHooks.performance.measure, performance.measure); + assertEquals(perfHooks.performance.clearMarks, performance.clearMarks); + assertEquals(perfHooks.performance.mark, performance.mark); + assertEquals(perfHooks.performance.now, performance.now); + assertEquals( + perfHooks.performance.getEntriesByName, + performance.getEntriesByName, + ); + assertEquals( + perfHooks.performance.getEntriesByType, + performance.getEntriesByType, + ); + // @ts-ignore toJSON is not in Performance interface + assertEquals(perfHooks.performance.toJSON, performance.toJSON); + perfHooks.performance.measure("test"); + perfHooks.performance.mark("test"); + perfHooks.performance.clearMarks("test"); + perfHooks.performance.now(); + assertEquals(perfHooks.performance.getEntriesByName("event", "mark"), []); + assertEquals(perfHooks.performance.getEntriesByType("mark"), []); + // @ts-ignore toJSON is not in Performance interface + perfHooks.performance.toJSON(); + }, +}); + +Deno.test({ + name: "[perf_hooks] performance destructured", + fn() { + performance.measure("test"); + performance.mark("test"); + performance.clearMarks("test"); + performance.now(); + // @ts-ignore toJSON is not in Performance interface + performance.toJSON(); + }, +}); + +Deno.test({ + name: "[perf_hooks] PerformanceEntry", + fn() { + assertEquals<unknown>(perfHooks.PerformanceEntry, PerformanceEntry); + }, +}); + +Deno.test({ + name: "[perf_hooks] performance.timeOrigin", + fn() { + assertEquals(typeof performance.timeOrigin, "number"); + assertThrows(() => { + // @ts-expect-error: Cannot assign to 'timeOrigin' because it is a read-only property + performance.timeOrigin = 1; + }); + }, +}); diff --git a/tests/unit_node/process_test.ts b/tests/unit_node/process_test.ts new file mode 100644 index 000000000..4f4703d35 --- /dev/null +++ b/tests/unit_node/process_test.ts @@ -0,0 +1,986 @@ +// deno-lint-ignore-file no-undef +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import process, { argv, env } from "node:process"; +import { Readable } from "node:stream"; +import { once } from "node:events"; +import { + assert, + assertEquals, + assertFalse, + assertObjectMatch, + assertStrictEquals, + assertThrows, +} from "@test_util/std/assert/mod.ts"; +import { stripColor } from "@test_util/std/fmt/colors.ts"; +import * as path from "@test_util/std/path/mod.ts"; +import { delay } from "@test_util/std/async/delay.ts"; + +const testDir = new URL(".", import.meta.url); + +Deno.test({ + name: "process.cwd and process.chdir success", + fn() { + assertEquals(process.cwd(), Deno.cwd()); + + const currentDir = Deno.cwd(); + + const tempDir = Deno.makeTempDirSync(); + process.chdir(tempDir); + assertEquals( + Deno.realPathSync(process.cwd()), + Deno.realPathSync(tempDir), + ); + + process.chdir(currentDir); + }, +}); + +Deno.test({ + name: "process.chdir failure", + fn() { + assertThrows( + () => { + process.chdir("non-existent-directory-name"); + }, + Deno.errors.NotFound, + "file", + // On every OS Deno returns: "No such file" except for Windows, where it's: + // "The system cannot find the file specified. (os error 2)" so "file" is + // the only common string here. + ); + }, +}); + +Deno.test({ + name: "process.version", + fn() { + assertEquals(typeof process, "object"); + assertEquals(typeof process.version, "string"); + assertEquals(typeof process.versions, "object"); + assertEquals(typeof process.versions.node, "string"); + assertEquals(typeof process.versions.v8, "string"); + assertEquals(typeof process.versions.uv, "string"); + assertEquals(typeof process.versions.zlib, "string"); + assertEquals(typeof process.versions.brotli, "string"); + assertEquals(typeof process.versions.ares, "string"); + assertEquals(typeof process.versions.modules, "string"); + assertEquals(typeof process.versions.nghttp2, "string"); + assertEquals(typeof process.versions.napi, "string"); + assertEquals(typeof process.versions.llhttp, "string"); + assertEquals(typeof process.versions.openssl, "string"); + assertEquals(typeof process.versions.cldr, "string"); + assertEquals(typeof process.versions.icu, "string"); + assertEquals(typeof process.versions.tz, "string"); + assertEquals(typeof process.versions.unicode, "string"); + // These two are not present in `process.versions` in Node, but we + // add them anyway + assertEquals(typeof process.versions.deno, "string"); + assertEquals(typeof process.versions.typescript, "string"); + }, +}); + +Deno.test({ + name: "process.platform", + fn() { + assertEquals(typeof process.platform, "string"); + }, +}); + +Deno.test({ + name: "process.mainModule", + fn() { + assertEquals(process.mainModule, undefined); + // Check that it is writable + // @ts-ignore these are deprecated now + process.mainModule = "foo"; + // @ts-ignore these are deprecated now + assertEquals(process.mainModule, "foo"); + }, +}); + +Deno.test({ + name: "process.arch", + fn() { + assertEquals(typeof process.arch, "string"); + if (Deno.build.arch == "x86_64") { + assertEquals(process.arch, "x64"); + } else if (Deno.build.arch == "aarch64") { + assertEquals(process.arch, "arm64"); + } else { + throw new Error("unreachable"); + } + }, +}); + +Deno.test({ + name: "process.pid", + fn() { + assertEquals(typeof process.pid, "number"); + assertEquals(process.pid, Deno.pid); + }, +}); + +Deno.test({ + name: "process.ppid", + fn() { + assertEquals(typeof process.ppid, "number"); + assertEquals(process.ppid, Deno.ppid); + }, +}); + +Deno.test({ + name: "process.on", + async fn() { + assertEquals(typeof process.on, "function"); + + let triggered = false; + process.on("exit", () => { + triggered = true; + }); + // @ts-ignore fix the type here + process.emit("exit"); + assert(triggered); + + const cwd = path.dirname(path.fromFileUrl(import.meta.url)); + + const command = new Deno.Command(Deno.execPath(), { + args: [ + "run", + "--quiet", + "--unstable", + "./testdata/process_exit.ts", + ], + cwd, + }); + const { stdout } = await command.output(); + + const decoder = new TextDecoder(); + assertEquals(stripColor(decoder.decode(stdout).trim()), "1\n2"); + }, +}); + +Deno.test({ + name: "process.on signal", + ignore: Deno.build.os == "windows", + async fn() { + const process = new Deno.Command(Deno.execPath(), { + args: [ + "eval", + ` + import process from "node:process"; + setInterval(() => {}, 1000); + process.on("SIGINT", () => { + console.log("foo"); + }); + `, + ], + stdout: "piped", + stderr: "null", + }).spawn(); + await delay(500); + for (const _ of Array(3)) { + process.kill("SIGINT"); + await delay(20); + } + await delay(20); + process.kill("SIGTERM"); + const output = await process.output(); + assertEquals(new TextDecoder().decode(output.stdout), "foo\nfoo\nfoo\n"); + }, +}); + +Deno.test({ + name: "process.off signal", + ignore: Deno.build.os == "windows", + async fn() { + const process = new Deno.Command(Deno.execPath(), { + args: [ + "eval", + ` + import process from "node:process"; + setInterval(() => {}, 1000); + const listener = () => { + console.log("foo"); + process.off("SIGINT") + }; + process.on("SIGINT", listener); + `, + ], + stdout: "piped", + stderr: "null", + }).spawn(); + await delay(500); + for (const _ of Array(3)) { + try { + process.kill("SIGINT"); + } catch { /* should die after the first one */ } + await delay(20); + } + await delay(20); + try { + process.kill("SIGTERM"); + } catch { /* should be dead, avoid hanging just in case */ } + const output = await process.output(); + assertEquals(new TextDecoder().decode(output.stdout), "foo\n"); + }, +}); + +Deno.test({ + name: "process.on SIGBREAK doesn't throw", + fn() { + const listener = () => {}; + process.on("SIGBREAK", listener); + process.off("SIGBREAK", listener); + }, +}); + +Deno.test({ + name: "process.on SIGTERM doesn't throw on windows", + ignore: Deno.build.os !== "windows", + fn() { + const listener = () => {}; + process.on("SIGTERM", listener); + process.off("SIGTERM", listener); + }, +}); + +Deno.test({ + name: "process.argv", + fn() { + assert(Array.isArray(argv)); + assert(Array.isArray(process.argv)); + assert( + process.argv[0].match(/[^/\\]*deno[^/\\]*$/), + "deno included in the file name of argv[0]", + ); + assertEquals( + process.argv[1], + path.fromFileUrl(Deno.mainModule), + ); + // argv supports array methods. + assert(Array.isArray(process.argv.slice(2))); + assertEquals(process.argv.indexOf(Deno.execPath()), 0); + assertEquals(process.argv.indexOf(path.fromFileUrl(Deno.mainModule)), 1); + }, +}); + +Deno.test({ + name: "process.argv0", + fn() { + assertEquals(typeof process.argv0, "string"); + assert( + process.argv0.match(/[^/\\]*deno[^/\\]*$/), + "deno included in the file name of argv[0]", + ); + // Setting should be a noop + process.argv0 = "foobar"; + assert( + process.argv0.match(/[^/\\]*deno[^/\\]*$/), + "deno included in the file name of argv[0]", + ); + }, +}); + +Deno.test({ + name: "process.execArgv", + fn() { + assert(Array.isArray(process.execArgv)); + assert(process.execArgv.length == 0); + // execArgv supports array methods. + assert(Array.isArray(process.argv.slice(0))); + assertEquals(process.argv.indexOf("foo"), -1); + }, +}); + +Deno.test({ + name: "process.env", + fn() { + Deno.env.set("HELLO", "WORLD"); + + assertObjectMatch(process.env, Deno.env.toObject()); + + assertEquals(typeof (process.env.HELLO), "string"); + assertEquals(process.env.HELLO, "WORLD"); + + assertEquals(typeof env.HELLO, "string"); + assertEquals(env.HELLO, "WORLD"); + + assert(Object.getOwnPropertyNames(process.env).includes("HELLO")); + assert(Object.keys(process.env).includes("HELLO")); + + assert(Object.prototype.hasOwnProperty.call(process.env, "HELLO")); + assert( + !Object.prototype.hasOwnProperty.call( + process.env, + "SURELY_NON_EXISTENT_VAR", + ), + ); + + // deno-lint-ignore no-prototype-builtins + assert(process.env.hasOwnProperty("HELLO")); + assert("HELLO" in process.env); + assert(Object.keys(process.env.valueOf()).includes("HELLO")); + + assertEquals(process.env.toString(), "[object Object]"); + assertEquals(process.env.toLocaleString(), "[object Object]"); + + // should not error when assigning false to an env var + process.env.HELLO = false as unknown as string; + assertEquals(process.env.HELLO, "false"); + process.env.HELLO = "WORLD"; + assertEquals(process.env.HELLO, "WORLD"); + }, +}); + +Deno.test({ + name: "process.env requires scoped env permission", + permissions: { env: ["FOO"] }, + fn() { + Deno.env.set("FOO", "1"); + assert("FOO" in process.env); + assertFalse("BAR" in process.env); + assert(Object.hasOwn(process.env, "FOO")); + assertFalse(Object.hasOwn(process.env, "BAR")); + }, +}); + +Deno.test({ + name: "process.env doesn't throw with invalid env var names", + fn() { + assertEquals(process.env[""], undefined); + assertEquals(process.env["\0"], undefined); + assertEquals(process.env["=c:"], undefined); + assertFalse(Object.hasOwn(process.env, "")); + assertFalse(Object.hasOwn(process.env, "\0")); + assertFalse(Object.hasOwn(process.env, "=c:")); + assertFalse("" in process.env); + assertFalse("\0" in process.env); + assertFalse("=c:" in process.env); + }, +}); + +Deno.test({ + name: "process.stdin", + fn() { + assertEquals(process.stdin.fd, Deno.stdin.rid); + assertEquals(process.stdin.isTTY, Deno.stdin.isTerminal()); + }, +}); + +Deno.test({ + name: "process.stdin readable with a TTY", + // TODO(PolarETech): Run this test even in non tty environment + ignore: !Deno.stdin.isTerminal(), + // stdin resource is present before the test starts. + sanitizeResources: false, + async fn() { + const { promise, resolve } = Promise.withResolvers<void>(); + const expected = ["foo", "bar", null, "end"]; + const data: (string | null)[] = []; + + process.stdin.setEncoding("utf8"); + process.stdin.on("readable", () => { + data.push(process.stdin.read()); + }); + process.stdin.on("end", () => { + data.push("end"); + }); + + process.stdin.push("foo"); + process.nextTick(() => { + process.stdin.push("bar"); + process.nextTick(() => { + process.stdin.push(null); + resolve(); + }); + }); + + await promise; + assertEquals(process.stdin.readableHighWaterMark, 0); + assertEquals(data, expected); + }, +}); + +Deno.test({ + name: "process.stdin readable with piping a file", + async fn() { + const expected = ["65536", "foo", "bar", "null", "end"]; + const scriptPath = "./testdata/process_stdin.ts"; + const filePath = "./testdata/process_stdin_dummy.txt"; + + const shell = Deno.build.os === "windows" ? "cmd.exe" : "/bin/sh"; + const cmd = `"${Deno.execPath()}" run ${scriptPath} < ${filePath}`; + const args = Deno.build.os === "windows" ? ["/d", "/c", cmd] : ["-c", cmd]; + + const p = new Deno.Command(shell, { + args, + stdin: "null", + stdout: "piped", + stderr: "null", + windowsRawArguments: true, + cwd: testDir, + }); + + const { stdout } = await p.output(); + const data = new TextDecoder().decode(stdout).trim().split("\n"); + assertEquals(data, expected); + }, +}); + +Deno.test({ + name: "process.stdin readable with piping a stream", + async fn() { + const expected = ["16384", "foo", "bar", "null", "end"]; + const scriptPath = "./testdata/process_stdin.ts"; + + const command = new Deno.Command(Deno.execPath(), { + args: ["run", scriptPath], + stdin: "piped", + stdout: "piped", + stderr: "null", + cwd: testDir, + }); + const child = command.spawn(); + + const writer = await child.stdin.getWriter(); + writer.ready + .then(() => writer.write(new TextEncoder().encode("foo\nbar"))) + .then(() => writer.releaseLock()) + .then(() => child.stdin.close()); + + const { stdout } = await child.output(); + const data = new TextDecoder().decode(stdout).trim().split("\n"); + assertEquals(data, expected); + }, +}); + +Deno.test({ + name: "process.stdin readable with piping a socket", + ignore: Deno.build.os === "windows", + async fn() { + const expected = ["16384", "foo", "bar", "null", "end"]; + const scriptPath = "./testdata/process_stdin.ts"; + + const listener = Deno.listen({ hostname: "127.0.0.1", port: 9000 }); + listener.accept().then(async (conn) => { + await conn.write(new TextEncoder().encode("foo\nbar")); + conn.close(); + listener.close(); + }); + + const shell = "/bin/bash"; + const cmd = + `"${Deno.execPath()}" run ${scriptPath} < /dev/tcp/127.0.0.1/9000`; + const args = ["-c", cmd]; + + const p = new Deno.Command(shell, { + args, + stdin: "null", + stdout: "piped", + stderr: "null", + cwd: testDir, + }); + + const { stdout } = await p.output(); + const data = new TextDecoder().decode(stdout).trim().split("\n"); + assertEquals(data, expected); + }, +}); + +Deno.test({ + name: "process.stdin readable with null", + async fn() { + const expected = ["65536", "null", "end"]; + const scriptPath = "./testdata/process_stdin.ts"; + + const command = new Deno.Command(Deno.execPath(), { + args: ["run", scriptPath], + stdin: "null", + stdout: "piped", + stderr: "null", + cwd: testDir, + }); + + const { stdout } = await command.output(); + const data = new TextDecoder().decode(stdout).trim().split("\n"); + assertEquals(data, expected); + }, +}); + +// TODO(kt3k): Enable this test case. 'readable' event handler in +// `process_stdin.ts` doesn't work now +Deno.test({ + name: "process.stdin readable with unsuitable stdin", + ignore: true, + // // TODO(PolarETech): Prepare a similar test that can be run on Windows + // ignore: Deno.build.os === "windows", + async fn() { + const expected = ["16384", "null", "end"]; + const scriptPath = "./testdata/process_stdin.ts"; + const directoryPath = "./testdata/"; + + const shell = "/bin/bash"; + const cmd = `"${Deno.execPath()}" run ${scriptPath} < ${directoryPath}`; + const args = ["-c", cmd]; + + const p = new Deno.Command(shell, { + args, + stdin: "null", + stdout: "piped", + stderr: "null", + windowsRawArguments: true, + cwd: testDir, + }); + + const { stdout } = await p.output(); + const data = new TextDecoder().decode(stdout).trim().split("\n"); + assertEquals(data, expected); + }, +}); + +Deno.test({ + name: "process.stdout", + fn() { + assertEquals(process.stdout.fd, Deno.stdout.rid); + const isTTY = Deno.stdout.isTerminal(); + assertEquals(process.stdout.isTTY, isTTY); + const consoleSize = isTTY ? Deno.consoleSize() : undefined; + assertEquals(process.stdout.columns, consoleSize?.columns); + assertEquals(process.stdout.rows, consoleSize?.rows); + assertEquals( + `${process.stdout.getWindowSize()}`, + `${consoleSize && [consoleSize.columns, consoleSize.rows]}`, + ); + + if (isTTY) { + assertStrictEquals(process.stdout.cursorTo(1, 2, () => {}), true); + assertStrictEquals(process.stdout.moveCursor(3, 4, () => {}), true); + assertStrictEquals(process.stdout.clearLine(1, () => {}), true); + assertStrictEquals(process.stdout.clearScreenDown(() => {}), true); + } else { + assertStrictEquals(process.stdout.cursorTo, undefined); + assertStrictEquals(process.stdout.moveCursor, undefined); + assertStrictEquals(process.stdout.clearLine, undefined); + assertStrictEquals(process.stdout.clearScreenDown, undefined); + } + }, +}); + +Deno.test({ + name: "process.stderr", + fn() { + assertEquals(process.stderr.fd, Deno.stderr.rid); + const isTTY = Deno.stderr.isTerminal(); + assertEquals(process.stderr.isTTY, isTTY); + const consoleSize = isTTY ? Deno.consoleSize() : undefined; + assertEquals(process.stderr.columns, consoleSize?.columns); + assertEquals(process.stderr.rows, consoleSize?.rows); + assertEquals( + `${process.stderr.getWindowSize()}`, + `${consoleSize && [consoleSize.columns, consoleSize.rows]}`, + ); + + if (isTTY) { + assertStrictEquals(process.stderr.cursorTo(1, 2, () => {}), true); + assertStrictEquals(process.stderr.moveCursor(3, 4, () => {}), true); + assertStrictEquals(process.stderr.clearLine(1, () => {}), true); + assertStrictEquals(process.stderr.clearScreenDown(() => {}), true); + } else { + assertStrictEquals(process.stderr.cursorTo, undefined); + assertStrictEquals(process.stderr.moveCursor, undefined); + assertStrictEquals(process.stderr.clearLine, undefined); + assertStrictEquals(process.stderr.clearScreenDown, undefined); + } + }, +}); + +Deno.test({ + name: "process.nextTick", + async fn() { + let withoutArguments = false; + process.nextTick(() => { + withoutArguments = true; + }); + + const expected = 12; + let result; + process.nextTick((x: number) => { + result = x; + }, 12); + + await delay(10); + assert(withoutArguments); + assertEquals(result, expected); + }, +}); + +Deno.test({ + name: "process.hrtime", + // TODO(kt3k): Enable this test + ignore: true, + fn() { + const [sec0, nano0] = process.hrtime(); + // seconds and nano seconds are positive integers. + assert(sec0 > 0); + assert(Number.isInteger(sec0)); + assert(nano0 > 0); + assert(Number.isInteger(nano0)); + + const [sec1, nano1] = process.hrtime(); + // the later call returns bigger value + assert(sec1 >= sec0); + assert(nano1 > nano0); + + const [sec2, nano2] = process.hrtime([sec1, nano1]); + // the difference of the 2 calls is a small positive value. + assertEquals(sec2, 0); + assert(nano2 > 0); + }, +}); + +Deno.test({ + name: "process.hrtime.bigint", + fn() { + const time = process.hrtime.bigint(); + assertEquals(typeof time, "bigint"); + assert(time > 0n); + }, +}); + +Deno.test("process.on, process.off, process.removeListener doesn't throw on unimplemented events", () => { + const events = [ + "beforeExit", + "disconnect", + "message", + "multipleResolves", + "rejectionHandled", + "uncaughtException", + "uncaughtExceptionMonitor", + "unhandledRejection", + "worker", + ]; + const handler = () => {}; + events.forEach((ev) => { + process.on(ev, handler); + assertEquals(process.listenerCount(ev), 1); + process.off(ev, handler); + assertEquals(process.listenerCount(ev), 0); + process.on(ev, handler); + assertEquals(process.listenerCount(ev), 1); + process.removeListener(ev, handler); + assertEquals(process.listenerCount(ev), 0); + }); +}); + +Deno.test("process.memoryUsage()", () => { + const mem = process.memoryUsage(); + assert(typeof mem.rss === "number"); + assert(typeof mem.heapTotal === "number"); + assert(typeof mem.heapUsed === "number"); + assert(typeof mem.external === "number"); + assert(typeof mem.arrayBuffers === "number"); + assertEquals(mem.arrayBuffers, 0); +}); + +Deno.test("process.memoryUsage.rss()", () => { + const rss = process.memoryUsage.rss(); + assert(typeof rss === "number"); +}); + +Deno.test("process.exitCode", () => { + assertEquals(process.exitCode, undefined); + process.exitCode = 127; + assertEquals(process.exitCode, 127); + // deno-lint-ignore no-explicit-any + (process.exitCode as any) = "asdf"; + // deno-lint-ignore no-explicit-any + assertEquals(process.exitCode as any, "asdf"); + // deno-lint-ignore no-explicit-any + (process.exitCode as any) = "10"; + process.exitCode = undefined; // reset +}); + +async function exitCodeTest(codeText: string, expectedExitCode: number) { + const command = new Deno.Command(Deno.execPath(), { + args: [ + "eval", + codeText, + ], + cwd: testDir, + }); + const { code } = await command.output(); + assertEquals(code, expectedExitCode); +} + +Deno.test("process.exitCode in should change exit code", async () => { + await exitCodeTest( + "import process from 'node:process'; process.exitCode = 127;", + 127, + ); + await exitCodeTest( + "import process from 'node:process'; process.exitCode = 2.5;", + 2, + ); + await exitCodeTest( + "import process from 'node:process'; process.exitCode = '10';", + 10, + ); + await exitCodeTest( + "import process from 'node:process'; process.exitCode = '0x10';", + 16, + ); + await exitCodeTest( + "import process from 'node:process'; process.exitCode = NaN;", + 0, + ); +}); + +Deno.test("Deno.exit should override process exit", async () => { + await exitCodeTest( + "import process from 'node:process'; process.exitCode = 10; Deno.exit(12);", + 12, + ); +}); + +Deno.test("process.config", () => { + assert(process.config !== undefined); + assert(process.config.target_defaults !== undefined); + assert(process.config.variables !== undefined); +}); + +Deno.test("process._exiting", () => { + // @ts-ignore fix the type here + assert(process._exiting === false); +}); + +Deno.test("process.execPath", () => { + assertEquals(process.execPath, process.argv[0]); +}); + +Deno.test("process.execPath is writable", () => { + // pnpm writes to process.execPath + // https://github.com/pnpm/pnpm/blob/67d8b65d2e8da1df3725034b8c5b1fcf3af4ad81/packages/config/src/index.ts#L175 + const originalExecPath = process.execPath; + try { + process.execPath = "/path/to/node"; + assertEquals(process.execPath, "/path/to/node"); + } finally { + process.execPath = originalExecPath; + } +}); + +Deno.test("process.getgid", () => { + if (Deno.build.os === "windows") { + assertEquals(process.getgid, undefined); + } else { + assertEquals(process.getgid?.(), Deno.gid()); + } +}); + +Deno.test("process.getuid", () => { + if (Deno.build.os === "windows") { + assertEquals(process.getuid, undefined); + } else { + assertEquals(process.getuid?.(), Deno.uid()); + } +}); + +Deno.test("process.geteuid", () => { + if (Deno.build.os === "windows") { + assertEquals(process.geteuid, undefined); + } else { + assert(typeof process.geteuid?.() === "number"); + } +}); + +Deno.test({ + name: "process.exit", + async fn() { + const command = new Deno.Command(Deno.execPath(), { + args: [ + "run", + "--quiet", + "--unstable", + "./testdata/process_exit2.ts", + ], + cwd: testDir, + }); + const { stdout } = await command.output(); + + const decoder = new TextDecoder(); + assertEquals(stripColor(decoder.decode(stdout).trim()), "exit"); + }, +}); + +Deno.test({ + name: "process.reallyExit", + async fn() { + const command = new Deno.Command(Deno.execPath(), { + args: [ + "run", + "--quiet", + "--unstable", + "./testdata/process_really_exit.ts", + ], + cwd: testDir, + }); + const { stdout } = await command.output(); + + const decoder = new TextDecoder(); + assertEquals(stripColor(decoder.decode(stdout).trim()), "really exited"); + }, +}); + +Deno.test({ + name: "process.stdout isn't closed when source stream ended", + async fn() { + const source = Readable.from(["foo", "bar"]); + + source.pipe(process.stdout); + await once(source, "end"); + + // Wait a bit to ensure that streaming is completely finished. + await delay(10); + + // This checks if the rid 1 is still valid. + assert(typeof process.stdout.isTTY === "boolean"); + }, +}); + +Deno.test({ + name: "process.title", + fn() { + assertEquals(process.title, "deno"); + // Verify that setting the value has no effect. + process.title = "foo"; + assertEquals(process.title, "deno"); + }, +}); + +Deno.test({ + name: "process.argv[1] in Worker", + async fn() { + const worker = new Worker( + `data:text/javascript,import process from "node:process";console.log(process.argv[1]);`, + { type: "module" }, + ); + await delay(10); + worker.terminate(); + }, +}); + +Deno.test({ + name: "process.binding('uv').errname", + ignore: Deno.build.os === "windows", + fn() { + // @ts-ignore: untyped internal binding, not actually supposed to be + // used by userland modules in Node.js + const uv = process.binding("uv"); + assert(uv.errname); + assert(typeof uv.errname === "function"); + assertEquals(uv.errname(-1), "EPERM"); + }, +}); + +Deno.test({ + name: "process.report", + fn() { + // The process.report is marked as possibly undefined in node 18 typings + if (!process.report) throw "No process report"; + + assert(typeof process.report.directory === "string"); + assert(typeof process.report.filename === "string"); + assert(typeof process.report.getReport === "function"); + assert(typeof process.report.reportOnFatalError === "boolean"); + assert(typeof process.report.reportOnSignal === "boolean"); + assert(typeof process.report.reportOnUncaughtException === "boolean"); + assert(typeof process.report.signal === "string"); + assert(typeof process.report.writeReport === "function"); + }, +}); + +Deno.test({ + name: "process.report.writeReport unimplemented result", + fn() { + // The process.report is marked as possibly undefined in node 18 typings + if (!process.report) throw "No process report"; + + assertEquals(process.report.writeReport(), ""); + }, +}); + +Deno.test({ + name: "process.report.getReport result", + fn() { + // The process.report is marked as possibly undefined in node 18 typings + if (!process.report) throw "No process report"; + + // deno-lint-ignore no-explicit-any + const result = process.report.getReport() as any; + + // test and remove dynamic parts + assert(typeof result.header.filename === "string"); + delete result.header.filename; + assert(typeof result.header.dumpEventTime === "object"); + delete result.header.dumpEventTime; + assert(typeof result.header.dumpEventTimeStamp === "number"); + delete result.header.dumpEventTimeStamp; + assert(typeof result.header.processId === "number"); + delete result.header.processId; + assert(typeof result.header.cwd === "string"); + delete result.header.cwd; + assert(typeof result.header.nodejsVersion === "string"); + assert(result.header.nodejsVersion.startsWith("v")); + delete result.header.nodejsVersion; + assert(typeof result.header.arch === "string"); + delete result.header.arch; + assert(typeof result.header.platform === "string"); + delete result.header.platform; + assert(typeof result.header.componentVersions === "object"); + delete result.header.componentVersions; + assert(typeof result.header.osName === "string"); + delete result.header.osName; + assert(typeof result.header.osMachine === "string"); + delete result.header.osMachine; + assert(Array.isArray(result.header.cpus)); + delete result.header.cpus; + assert(typeof result.header.networkInterfaces === "object"); + delete result.header.networkInterfaces; + assert(typeof result.header.host === "string"); + delete result.header.host; + + // test hardcoded part + assertEquals(result, { + header: { + reportVersion: 3, + event: "JavaScript API", + trigger: "GetReport", + threadId: 0, + commandLine: ["node"], + glibcVersionRuntime: "2.38", + glibcVersionCompiler: "2.38", + wordSize: 64, + release: { + name: "node", + headersUrl: + "https://nodejs.org/download/release/v21.2.0/node-v21.2.0-headers.tar.gz", + sourceUrl: + "https://nodejs.org/download/release/v21.2.0/node-v21.2.0.tar.gz", + }, + osRelease: undefined, + osVersion: undefined, + }, + javascriptStack: undefined, + javascriptHeap: undefined, + nativeStack: undefined, + resourceUsage: undefined, + uvthreadResourceUsage: undefined, + libuv: undefined, + workers: [], + environmentVariables: undefined, + userLimits: undefined, + sharedObjects: undefined, + }); + }, +}); diff --git a/tests/unit_node/querystring_test.ts b/tests/unit_node/querystring_test.ts new file mode 100644 index 000000000..9831d92ed --- /dev/null +++ b/tests/unit_node/querystring_test.ts @@ -0,0 +1,51 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { assertEquals } from "@test_util/std/assert/mod.ts"; +import { parse, stringify } from "node:querystring"; + +Deno.test({ + name: "stringify", + fn() { + assertEquals( + stringify({ + a: "hello", + b: 5, + c: true, + d: ["foo", "bar"], + }), + "a=hello&b=5&c=true&d=foo&d=bar", + ); + }, +}); + +Deno.test({ + name: "parse", + fn() { + assertEquals(parse("a=hello&b=5&c=true&d=foo&d=bar"), { + a: "hello", + b: "5", + c: "true", + d: ["foo", "bar"], + }); + }, +}); + +// https://github.com/denoland/deno/issues/21734 +Deno.test({ + name: "stringify options no encode", + fn() { + assertEquals( + stringify( + { + a: "hello", + b: 5, + c: true, + d: ["foo", "bar"], + }, + "&", + "=", + {}, + ), + "a=hello&b=5&c=true&d=foo&d=bar", + ); + }, +}); diff --git a/tests/unit_node/readline_test.ts b/tests/unit_node/readline_test.ts new file mode 100644 index 000000000..ecd1a893d --- /dev/null +++ b/tests/unit_node/readline_test.ts @@ -0,0 +1,27 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { createInterface, Interface } from "node:readline"; +import { assertInstanceOf } from "@test_util/std/assert/mod.ts"; +import { Readable, Writable } from "node:stream"; + +Deno.test("[node/readline] createInstance", () => { + const rl = createInterface({ + input: new Readable({ read() {} }), + output: new Writable(), + }); + + // deno-lint-ignore no-explicit-any + assertInstanceOf(rl, Interface as any); +}); + +// Test for https://github.com/denoland/deno/issues/19183 +Deno.test("[node/readline] don't throw on rl.question()", () => { + const rli = createInterface({ + input: new Readable({ read() {} }), + output: new Writable({ write() {} }), + terminal: true, + }); + + // Calling this would throw + rli.question("foo", () => rli.close()); + rli.close(); +}); diff --git a/tests/unit_node/repl_test.ts b/tests/unit_node/repl_test.ts new file mode 100644 index 000000000..adfc1d60a --- /dev/null +++ b/tests/unit_node/repl_test.ts @@ -0,0 +1,17 @@ +// deno-lint-ignore-file no-undef +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import repl from "node:repl"; +import { assert } from "@test_util/std/assert/mod.ts"; + +Deno.test({ + name: "repl module exports", + fn() { + assert(typeof repl.REPLServer !== "undefined"); + assert(typeof repl.start !== "undefined"); + // @ts-ignore not present in declaration files, but libraries depend on it + assert(typeof repl.builtinModules !== "undefined"); + // @ts-ignore not present in declaration files, but libraries depend on it + assert(typeof repl._builtinLibs !== "undefined"); + }, +}); diff --git a/tests/unit_node/stream_test.ts b/tests/unit_node/stream_test.ts new file mode 100644 index 000000000..ab81497d1 --- /dev/null +++ b/tests/unit_node/stream_test.ts @@ -0,0 +1,25 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import { assert } from "@test_util/std/assert/mod.ts"; +import { fromFileUrl, relative } from "@test_util/std/path/mod.ts"; +import { pipeline } from "node:stream/promises"; +import { createReadStream, createWriteStream } from "node:fs"; + +Deno.test("stream/promises pipeline", async () => { + const filePath = relative( + Deno.cwd(), + fromFileUrl(new URL("./testdata/lorem_ipsum.txt", import.meta.url)), + ); + const input = createReadStream(filePath); + const output = createWriteStream("lorem_ipsum.txt.copy"); + + await pipeline(input, output); + + const content = Deno.readTextFileSync("lorem_ipsum.txt.copy"); + assert(content.startsWith("Lorem ipsum dolor sit amet")); + try { + Deno.removeSync("lorem_ipsum.txt.copy"); + } catch { + // pass + } +}); diff --git a/tests/unit_node/string_decoder_test.ts b/tests/unit_node/string_decoder_test.ts new file mode 100644 index 000000000..768ae3b3a --- /dev/null +++ b/tests/unit_node/string_decoder_test.ts @@ -0,0 +1,167 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { assertEquals } from "@test_util/std/assert/mod.ts"; +import { Buffer } from "node:buffer"; +import { StringDecoder } from "node:string_decoder"; + +Deno.test({ + name: "String decoder is encoding utf8 correctly", + fn() { + let decoder; + + decoder = new StringDecoder("utf8"); + assertEquals(decoder.write(Buffer.from("E1", "hex")), ""); + assertEquals(decoder.end(), "\ufffd"); + + decoder = new StringDecoder("utf8"); + assertEquals(decoder.write(Buffer.from("E18B", "hex")), ""); + assertEquals(decoder.end(), "\ufffd"); + + decoder = new StringDecoder("utf8"); + assertEquals(decoder.write(Buffer.from("\ufffd")), "\ufffd"); + assertEquals(decoder.end(), ""); + + decoder = new StringDecoder("utf8"); + assertEquals( + decoder.write(Buffer.from("\ufffd\ufffd\ufffd")), + "\ufffd\ufffd\ufffd", + ); + assertEquals(decoder.end(), ""); + + decoder = new StringDecoder("utf8"); + assertEquals(decoder.write(Buffer.from("EFBFBDE2", "hex")), "\ufffd"); + assertEquals(decoder.end(), "\ufffd"); + + decoder = new StringDecoder("utf8"); + assertEquals(decoder.write(Buffer.from("F1", "hex")), ""); + assertEquals(decoder.write(Buffer.from("41F2", "hex")), "\ufffdA"); + assertEquals(decoder.end(), "\ufffd"); + }, +}); + +Deno.test({ + name: "String decoder is encoding base64 correctly", + fn() { + let decoder; + + decoder = new StringDecoder("base64"); + assertEquals(decoder.write(Buffer.from("E1", "hex")), ""); + assertEquals(decoder.end(), "4Q=="); + + decoder = new StringDecoder("base64"); + assertEquals(decoder.write(Buffer.from("E18B", "hex")), ""); + assertEquals(decoder.end(), "4Ys="); + + decoder = new StringDecoder("base64"); + assertEquals(decoder.write(Buffer.from("\ufffd")), "77+9"); + assertEquals(decoder.end(), ""); + + decoder = new StringDecoder("base64"); + assertEquals( + decoder.write(Buffer.from("\ufffd\ufffd\ufffd")), + "77+977+977+9", + ); + assertEquals(decoder.end(), ""); + + decoder = new StringDecoder("base64"); + assertEquals(decoder.write(Buffer.from("EFBFBDE2", "hex")), "77+9"); + assertEquals(decoder.end(), "4g=="); + + decoder = new StringDecoder("base64"); + assertEquals(decoder.write(Buffer.from("F1", "hex")), ""); + assertEquals(decoder.write(Buffer.from("41F2", "hex")), "8UHy"); + assertEquals(decoder.end(), ""); + }, +}); + +Deno.test({ + name: "String decoder is encoding hex correctly", + fn() { + let decoder; + + decoder = new StringDecoder("hex"); + assertEquals(decoder.write(Buffer.from("E1", "hex")), "e1"); + assertEquals(decoder.end(), ""); + + decoder = new StringDecoder("hex"); + assertEquals(decoder.write(Buffer.from("E18B", "hex")), "e18b"); + assertEquals(decoder.end(), ""); + + decoder = new StringDecoder("hex"); + assertEquals(decoder.write(Buffer.from("\ufffd")), "efbfbd"); + assertEquals(decoder.end(), ""); + + decoder = new StringDecoder("hex"); + assertEquals( + decoder.write(Buffer.from("\ufffd\ufffd\ufffd")), + "efbfbdefbfbdefbfbd", + ); + assertEquals(decoder.end(), ""); + + decoder = new StringDecoder("hex"); + assertEquals(decoder.write(Buffer.from("EFBFBDE2", "hex")), "efbfbde2"); + assertEquals(decoder.end(), ""); + + decoder = new StringDecoder("hex"); + assertEquals(decoder.write(Buffer.from("F1", "hex")), "f1"); + assertEquals(decoder.write(Buffer.from("41F2", "hex")), "41f2"); + assertEquals(decoder.end(), ""); + }, +}); + +Deno.test({ + name: + "String decoder with utf8 would handle incomplete character correctly when append", + fn() { + let decoder; + const specialCharactersText = "不完全な文字のテスト"; + const encodedBuffer = Buffer.from(specialCharactersText); + + decoder = new StringDecoder("utf8"); + let str = ""; + str += decoder.write(encodedBuffer.slice(0, 4)); + assertEquals(str, "不"); + str += decoder.write(encodedBuffer.slice(4)); + assertEquals(str, "不完全な文字のテスト"); + + decoder = new StringDecoder("utf8"); + str = ""; + str += decoder.write(encodedBuffer.slice(0, 4)); + str += decoder.write(encodedBuffer.slice(5)); + assertEquals(str, "不�全な文字のテスト"); + }, +}); + +Deno.test({ + name: "String decoder would have default encoding option as utf8", + fn() { + let decoder; + + decoder = new StringDecoder(); + assertEquals(decoder.write(Buffer.from("E1", "hex")), ""); + assertEquals(decoder.end(), "\ufffd"); + + decoder = new StringDecoder(); + assertEquals(decoder.write(Buffer.from("E18B", "hex")), ""); + assertEquals(decoder.end(), "\ufffd"); + + decoder = new StringDecoder(); + assertEquals(decoder.write(Buffer.from("\ufffd")), "\ufffd"); + assertEquals(decoder.end(), ""); + + decoder = new StringDecoder(); + assertEquals( + decoder.write(Buffer.from("\ufffd\ufffd\ufffd")), + "\ufffd\ufffd\ufffd", + ); + assertEquals(decoder.end(), ""); + + decoder = new StringDecoder(); + assertEquals(decoder.write(Buffer.from("EFBFBDE2", "hex")), "\ufffd"); + assertEquals(decoder.end(), "\ufffd"); + + decoder = new StringDecoder(); + assertEquals(decoder.write(Buffer.from("F1", "hex")), ""); + assertEquals(decoder.write(Buffer.from("41F2", "hex")), "\ufffdA"); + assertEquals(decoder.end(), "\ufffd"); + }, +}); diff --git a/tests/unit_node/testdata/add_global_property.js b/tests/unit_node/testdata/add_global_property.js new file mode 100644 index 000000000..814d17d0d --- /dev/null +++ b/tests/unit_node/testdata/add_global_property.js @@ -0,0 +1 @@ +globalThis.foo = "Hello"; diff --git a/tests/unit_node/testdata/add_global_property_run_main.js b/tests/unit_node/testdata/add_global_property_run_main.js new file mode 100644 index 000000000..c9db1cea6 --- /dev/null +++ b/tests/unit_node/testdata/add_global_property_run_main.js @@ -0,0 +1 @@ +globalThis.calledViaRunMain = true; diff --git a/tests/unit_node/testdata/binary_stdio.js b/tests/unit_node/testdata/binary_stdio.js new file mode 100644 index 000000000..aa370a933 --- /dev/null +++ b/tests/unit_node/testdata/binary_stdio.js @@ -0,0 +1,11 @@ +const buffer = new Uint8Array(10); +const nread = await Deno.stdin.read(buffer); + +if (nread != 10) { + throw new Error("Too little data read"); +} + +const nwritten = await Deno.stdout.write(buffer); +if (nwritten != 10) { + throw new Error("Too little data written"); +} diff --git a/tests/unit_node/testdata/child_process_stdio.js b/tests/unit_node/testdata/child_process_stdio.js new file mode 100644 index 000000000..b13b09562 --- /dev/null +++ b/tests/unit_node/testdata/child_process_stdio.js @@ -0,0 +1,16 @@ +import childProcess from "node:child_process"; +import process from "node:process"; +import * as path from "node:path"; +import { fileURLToPath } from "node:url"; + +const script = path.join( + path.dirname(fileURLToPath(import.meta.url)), + "node_modules", + "foo", + "index.js", +); + +const child = childProcess.spawn(process.execPath, [script], { + stdio: [process.stdin, process.stdout, process.stderr], +}); +child.on("close", () => console.log("close")); diff --git a/tests/unit_node/testdata/child_process_stdio_012.js b/tests/unit_node/testdata/child_process_stdio_012.js new file mode 100644 index 000000000..e3717f985 --- /dev/null +++ b/tests/unit_node/testdata/child_process_stdio_012.js @@ -0,0 +1,16 @@ +import childProcess from "node:child_process"; +import process from "node:process"; +import * as path from "node:path"; +import { fileURLToPath } from "node:url"; + +const script = path.join( + path.dirname(fileURLToPath(import.meta.url)), + "node_modules", + "foo", + "index.js", +); + +const child = childProcess.spawn(process.execPath, [script], { + stdio: [0, 1, 2], +}); +child.on("close", () => console.log("close")); diff --git a/tests/unit_node/testdata/child_process_unref.js b/tests/unit_node/testdata/child_process_unref.js new file mode 100644 index 000000000..8201ac44d --- /dev/null +++ b/tests/unit_node/testdata/child_process_unref.js @@ -0,0 +1,10 @@ +import cp from "node:child_process"; +import * as path from "node:path"; +import { fileURLToPath } from "node:url"; + +const script = path.join( + path.dirname(fileURLToPath(import.meta.url)), + "infinite_loop.js", +); +const childProcess = cp.spawn(Deno.execPath(), ["run", script]); +childProcess.unref(); diff --git a/tests/unit_node/testdata/exec_file_text_error.js b/tests/unit_node/testdata/exec_file_text_error.js new file mode 100644 index 000000000..9697e6044 --- /dev/null +++ b/tests/unit_node/testdata/exec_file_text_error.js @@ -0,0 +1,2 @@ +console.error("yikes!"); +Deno.exit(1); diff --git a/tests/unit_node/testdata/exec_file_text_output.js b/tests/unit_node/testdata/exec_file_text_output.js new file mode 100644 index 000000000..019c0f4bc --- /dev/null +++ b/tests/unit_node/testdata/exec_file_text_output.js @@ -0,0 +1 @@ +console.log("Hello World!"); diff --git a/tests/unit_node/testdata/infinite_loop.js b/tests/unit_node/testdata/infinite_loop.js new file mode 100644 index 000000000..0e6540a7b --- /dev/null +++ b/tests/unit_node/testdata/infinite_loop.js @@ -0,0 +1,3 @@ +while (true) { + await new Promise((resolve) => setTimeout(resolve, 1000)); +} diff --git a/tests/unit_node/testdata/lorem_ipsum.txt b/tests/unit_node/testdata/lorem_ipsum.txt new file mode 100644 index 000000000..08e00ed29 --- /dev/null +++ b/tests/unit_node/testdata/lorem_ipsum.txt @@ -0,0 +1 @@ +Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
\ No newline at end of file diff --git a/tests/unit_node/testdata/node_modules/foo/index.js b/tests/unit_node/testdata/node_modules/foo/index.js new file mode 100644 index 000000000..24faba789 --- /dev/null +++ b/tests/unit_node/testdata/node_modules/foo/index.js @@ -0,0 +1,4 @@ +console.log("foo"); +console.log(typeof require === "function"); +console.log(typeof module === "object"); +console.log(typeof exports === "object"); diff --git a/tests/unit_node/testdata/node_modules/foo/package.json b/tests/unit_node/testdata/node_modules/foo/package.json new file mode 100644 index 000000000..bde99de92 --- /dev/null +++ b/tests/unit_node/testdata/node_modules/foo/package.json @@ -0,0 +1,3 @@ +{ + "name": "foo" +} diff --git a/tests/unit_node/testdata/process_exit.ts b/tests/unit_node/testdata/process_exit.ts new file mode 100644 index 000000000..57351c087 --- /dev/null +++ b/tests/unit_node/testdata/process_exit.ts @@ -0,0 +1,19 @@ +import process from "node:process"; + +//deno-lint-ignore no-undef +process.on("exit", () => { + console.log(1); +}); + +function unexpected() { + console.log(null); +} +//deno-lint-ignore no-undef +process.on("exit", unexpected); +//deno-lint-ignore no-undef +process.removeListener("exit", unexpected); + +//deno-lint-ignore no-undef +process.on("exit", () => { + console.log(2); +}); diff --git a/tests/unit_node/testdata/process_exit2.ts b/tests/unit_node/testdata/process_exit2.ts new file mode 100644 index 000000000..3731f745a --- /dev/null +++ b/tests/unit_node/testdata/process_exit2.ts @@ -0,0 +1,4 @@ +import process from "node:process"; + +process.on("exit", () => console.log("exit")); +process.exit(); diff --git a/tests/unit_node/testdata/process_really_exit.ts b/tests/unit_node/testdata/process_really_exit.ts new file mode 100644 index 000000000..16f30b33d --- /dev/null +++ b/tests/unit_node/testdata/process_really_exit.ts @@ -0,0 +1,10 @@ +import process from "node:process"; + +//deno-lint-ignore no-undef +// @ts-ignore - Node typings don't even have this because it's +// been deprecated for 4 years. But it's used in `signal-exit`, +// which in turn is used in `node-tap`. +process.reallyExit = function () { + console.info("really exited"); +}; +process.exit(); diff --git a/tests/unit_node/testdata/process_stdin.ts b/tests/unit_node/testdata/process_stdin.ts new file mode 100644 index 000000000..23562b090 --- /dev/null +++ b/tests/unit_node/testdata/process_stdin.ts @@ -0,0 +1,11 @@ +import process from "node:process"; + +console.log(process.stdin.readableHighWaterMark); + +process.stdin.setEncoding("utf8"); +process.stdin.on("readable", () => { + console.log(process.stdin.read()); +}); +process.stdin.on("end", () => { + console.log("end"); +}); diff --git a/tests/unit_node/testdata/process_stdin_dummy.txt b/tests/unit_node/testdata/process_stdin_dummy.txt new file mode 100644 index 000000000..a907ec3f4 --- /dev/null +++ b/tests/unit_node/testdata/process_stdin_dummy.txt @@ -0,0 +1,2 @@ +foo +bar
\ No newline at end of file diff --git a/tests/unit_node/testdata/rsa_private.pem b/tests/unit_node/testdata/rsa_private.pem new file mode 100644 index 000000000..cd274ae6d --- /dev/null +++ b/tests/unit_node/testdata/rsa_private.pem @@ -0,0 +1,28 @@ +-----BEGIN PRIVATE KEY----- +MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQC33FiIiiexwLe/ +P8DZx5HsqFlmUO7/lvJ7necJVNwqdZ3ax5jpQB0p6uxfqeOvzcN3k5V7UFb/Am+n +kSNZMAZhsWzCU2Z4Pjh50QYz3f0Hour7/yIGStOLyYY3hgLK2K8TbhgjQPhdkw9+ +QtKlpvbL8fLgONAoGrVOFnRQGcr70iFffsm79mgZhKVMgYiHPJqJgGHvCtkGg9zM +gS7p63+Q3ZWedtFS2RhMX3uCBy/mH6EOlRCNBbRmA4xxNzyf5GQaki3T+Iz9tOMj +dPP+CwV2LqEdylmBuik8vrfTb3qIHLKKBAI8lXN26wWtA3kN4L7NP+cbKlCRlqct +vhmylLH1AgMBAAECggEBAJLZ6ti7yDKgY+LcT/NiBDqKyEUBlbMNZIW5vAPnBKbh +JIDO9WIv9Fs7qSpLbnFHnr0OYtGIfMPXtUiYkyw0QJSc+upHZMvbno4llpes0eHc +jWVTBWETON4oywvj/Kz53vRc9eiKhxVuVWyagNcQgYSprjzLA+9UTcWeB67Guyrf +8YJUE2LC23RiMA5nGYoSHfVRl0c75gj7A0X9nwpAI+xw3kcaVHRIhA6WowA3Pj1o +pK2t692+NLVRylpvMMSS4rziDexomFykCFukYWYB/kZOOSSETSsTWoMXXl1KqsoZ +8IW06NR4rXtIgQ3sTfbYKGZNF5nWFgZ+hJVx0We1Qg0CgYEA8UovlB4nrBm7xH+u +7XXBMbqxADQm5vaEZxw9eluc+tP7cIAI4sglMIvL/FMpbd2pEeP/BkR76NTDzzDu +PAZvUGRavgEjy0O9j2NAs/WPK4tZF+vFdunhnSh4EHAF4Ij9kbsUi90NOpbGfVqP +dOaHqzgHKoR23Cuusk9wFQ2XTV8CgYEAwxHdEYT9xrpfrHPqSBQPpO0dWGKJEkrW +Ob+76rSfuL8wGR4OBNmQdhLuU9zTIh22pog+XPnLPAecC+4yu/wtJ2SPCKiKDbJB +re0CKPyRfGqzvA3njXwMxXazU4kGs+2Fg+xu/iKbaIjxXrclBLhkxhBtySrwAFhx +xOk6fFcPLSsCgYEAqS/Mdr5CMRGGMH0bKhPUWEtAixUGZhJaunX5wY71Xoc/Gh4c +nO+b7BNJ/+5L8WZog0vr6PgiLhrqBaCYm2wjpyoG2o2wDHm+NAlzN/wp3G2EFhrS +xdOux+S1c0kpRcyoiAO2n29rNDa+jOzwBBcU8ACEPdLOCQl0IEFFJO33tl8CgYBY +DOIqnEsovsucvh3MNzHwkg8i7CdPGHSmUIN0J9/ItpPxYn2VdtccVOM6+3xZ8+uU +M/9iXGZ+TDkFsZk4/VUsaNmfYOQf1oyLA2ZsNcU90bQbeHNCi/H/19qOJFXgNaCE +sd5P3DMl9lptFGIjRVBHjvbfTQBUR5fi+BusMGfrTQKBgQCTtzMEJP2sef883AJr +XuGVPLzwLi9eTBvPzc5r5pfkvh7mDDmWFxHZm5kctvavqgy32uUPsQgMi1Kz67bU +s5dY9MCVrN2elhTLD8LOiAz8836o3AxFefm5cUWGaU/aZWDYR0QtNqFdyHyRaodo +JJfnfK+oK1Eq7+PvpXfVN9BkYw== +-----END PRIVATE KEY----- diff --git a/tests/unit_node/testdata/rsa_private_pkcs1.pem b/tests/unit_node/testdata/rsa_private_pkcs1.pem new file mode 100644 index 000000000..215e5cc51 --- /dev/null +++ b/tests/unit_node/testdata/rsa_private_pkcs1.pem @@ -0,0 +1,27 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIEpQIBAAKCAQEAt9xYiIonscC3vz/A2ceR7KhZZlDu/5bye53nCVTcKnWd2seY +6UAdKersX6njr83Dd5OVe1BW/wJvp5EjWTAGYbFswlNmeD44edEGM939B6Lq+/8i +BkrTi8mGN4YCytivE24YI0D4XZMPfkLSpab2y/Hy4DjQKBq1ThZ0UBnK+9IhX37J +u/ZoGYSlTIGIhzyaiYBh7wrZBoPczIEu6et/kN2VnnbRUtkYTF97ggcv5h+hDpUQ +jQW0ZgOMcTc8n+RkGpIt0/iM/bTjI3Tz/gsFdi6hHcpZgbopPL630296iByyigQC +PJVzdusFrQN5DeC+zT/nGypQkZanLb4ZspSx9QIDAQABAoIBAQCS2erYu8gyoGPi +3E/zYgQ6ishFAZWzDWSFubwD5wSm4SSAzvViL/RbO6kqS25xR569DmLRiHzD17VI +mJMsNECUnPrqR2TL256OJZaXrNHh3I1lUwVhEzjeKMsL4/ys+d70XPXoiocVblVs +moDXEIGEqa48ywPvVE3Fngeuxrsq3/GCVBNiwtt0YjAOZxmKEh31UZdHO+YI+wNF +/Z8KQCPscN5HGlR0SIQOlqMANz49aKStrevdvjS1UcpabzDEkuK84g3saJhcpAhb +pGFmAf5GTjkkhE0rE1qDF15dSqrKGfCFtOjUeK17SIEN7E322ChmTReZ1hYGfoSV +cdFntUINAoGBAPFKL5QeJ6wZu8R/ru11wTG6sQA0Jub2hGccPXpbnPrT+3CACOLI +JTCLy/xTKW3dqRHj/wZEe+jUw88w7jwGb1BkWr4BI8tDvY9jQLP1jyuLWRfrxXbp +4Z0oeBBwBeCI/ZG7FIvdDTqWxn1aj3Tmh6s4ByqEdtwrrrJPcBUNl01fAoGBAMMR +3RGE/ca6X6xz6kgUD6TtHVhiiRJK1jm/u+q0n7i/MBkeDgTZkHYS7lPc0yIdtqaI +Plz5yzwHnAvuMrv8LSdkjwioig2yQa3tAij8kXxqs7wN5418DMV2s1OJBrPthYPs +bv4im2iI8V63JQS4ZMYQbckq8ABYccTpOnxXDy0rAoGBAKkvzHa+QjERhjB9GyoT +1FhLQIsVBmYSWrp1+cGO9V6HPxoeHJzvm+wTSf/uS/FmaINL6+j4Ii4a6gWgmJts +I6cqBtqNsAx5vjQJczf8KdxthBYa0sXTrsfktXNJKUXMqIgDtp9vazQ2vozs8AQX +FPAAhD3SzgkJdCBBRSTt97ZfAoGAWAziKpxLKL7LnL4dzDcx8JIPIuwnTxh0plCD +dCffyLaT8WJ9lXbXHFTjOvt8WfPrlDP/Ylxmfkw5BbGZOP1VLGjZn2DkH9aMiwNm +bDXFPdG0G3hzQovx/9fajiRV4DWghLHeT9wzJfZabRRiI0VQR472300AVEeX4vgb +rDBn600CgYEAk7czBCT9rHn/PNwCa17hlTy88C4vXkwbz83Oa+aX5L4e5gw5lhcR +2ZuZHLb2r6oMt9rlD7EIDItSs+u21LOXWPTAlazdnpYUyw/CzogM/PN+qNwMRXn5 +uXFFhmlP2mVg2EdELTahXch8kWqHaCSX53yvqCtRKu/j76V31TfQZGM= +-----END RSA PRIVATE KEY----- diff --git a/tests/unit_node/testdata/rsa_public.pem b/tests/unit_node/testdata/rsa_public.pem new file mode 100644 index 000000000..8c30cfa52 --- /dev/null +++ b/tests/unit_node/testdata/rsa_public.pem @@ -0,0 +1,9 @@ +-----BEGIN PUBLIC KEY----- +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAt9xYiIonscC3vz/A2ceR +7KhZZlDu/5bye53nCVTcKnWd2seY6UAdKersX6njr83Dd5OVe1BW/wJvp5EjWTAG +YbFswlNmeD44edEGM939B6Lq+/8iBkrTi8mGN4YCytivE24YI0D4XZMPfkLSpab2 +y/Hy4DjQKBq1ThZ0UBnK+9IhX37Ju/ZoGYSlTIGIhzyaiYBh7wrZBoPczIEu6et/ +kN2VnnbRUtkYTF97ggcv5h+hDpUQjQW0ZgOMcTc8n+RkGpIt0/iM/bTjI3Tz/gsF +di6hHcpZgbopPL630296iByyigQCPJVzdusFrQN5DeC+zT/nGypQkZanLb4ZspSx +9QIDAQAB +-----END PUBLIC KEY----- diff --git a/tests/unit_node/testdata/worker_module/index.js b/tests/unit_node/testdata/worker_module/index.js new file mode 100644 index 000000000..a3e976b65 --- /dev/null +++ b/tests/unit_node/testdata/worker_module/index.js @@ -0,0 +1,3 @@ +import { myFunction } from "./other_file.js"; + +myFunction().then(() => {}); diff --git a/tests/unit_node/testdata/worker_module/other_file.js b/tests/unit_node/testdata/worker_module/other_file.js new file mode 100644 index 000000000..41789dfe8 --- /dev/null +++ b/tests/unit_node/testdata/worker_module/other_file.js @@ -0,0 +1,3 @@ +export async function myFunction() { + await new Promise((resolve) => setTimeout(resolve, 100)); +} diff --git a/tests/unit_node/testdata/worker_module/package.json b/tests/unit_node/testdata/worker_module/package.json new file mode 100644 index 000000000..486d2f82b --- /dev/null +++ b/tests/unit_node/testdata/worker_module/package.json @@ -0,0 +1,4 @@ +{ + "name": "foo", + "type": "module" +} diff --git a/tests/unit_node/testdata/worker_threads.mjs b/tests/unit_node/testdata/worker_threads.mjs new file mode 100644 index 000000000..03dc462f0 --- /dev/null +++ b/tests/unit_node/testdata/worker_threads.mjs @@ -0,0 +1,34 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +import { + getEnvironmentData, + isMainThread, + parentPort, + threadId, + workerData, +} from "node:worker_threads"; +import { once } from "node:events"; + +async function message(expectedMessage) { + const [message] = await once(parentPort, "message"); + if (message !== expectedMessage) { + console.log(`Expected the message "${expectedMessage}", but got`, message); + // fail test + parentPort.close(); + } +} + +await message("Hello, how are you my thread?"); + +parentPort.postMessage("I'm fine!"); + +await new Promise((resolve) => setTimeout(resolve, 100)); + +parentPort.postMessage({ + isMainThread, + threadId, + workerData: Array.isArray(workerData) && + workerData[workerData.length - 1] instanceof MessagePort + ? workerData.slice(0, -1) + : workerData, + envData: [getEnvironmentData("test"), getEnvironmentData(1)], +}); diff --git a/tests/unit_node/timers_test.ts b/tests/unit_node/timers_test.ts new file mode 100644 index 000000000..f5cccc9a9 --- /dev/null +++ b/tests/unit_node/timers_test.ts @@ -0,0 +1,62 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import { assert, fail } from "@test_util/std/assert/mod.ts"; +import * as timers from "node:timers"; +import * as timersPromises from "node:timers/promises"; + +Deno.test("[node/timers setTimeout]", () => { + { + const { clearTimeout, setTimeout } = timers; + const id = setTimeout(() => {}); + clearTimeout(id); + } + + { + const id = timers.setTimeout(() => {}); + timers.clearTimeout(id); + } +}); + +Deno.test("[node/timers setInterval]", () => { + { + const { clearInterval, setInterval } = timers; + const id = setInterval(() => {}); + clearInterval(id); + } + + { + const id = timers.setInterval(() => {}); + timers.clearInterval(id); + } +}); + +Deno.test("[node/timers setImmediate]", () => { + { + const { clearImmediate, setImmediate } = timers; + const id = setImmediate(() => {}); + clearImmediate(id); + } + + { + const id = timers.setImmediate(() => {}); + timers.clearImmediate(id); + } +}); + +Deno.test("[node/timers/promises setTimeout]", () => { + const { setTimeout } = timersPromises; + const p = setTimeout(0); + + assert(p instanceof Promise); + return p; +}); + +// Regression test for https://github.com/denoland/deno/issues/17981 +Deno.test("[node/timers refresh cancelled timer]", () => { + const { setTimeout, clearTimeout } = timers; + const p = setTimeout(() => { + fail(); + }, 1); + clearTimeout(p); + p.refresh(); +}); diff --git a/tests/unit_node/tls_test.ts b/tests/unit_node/tls_test.ts new file mode 100644 index 000000000..d87df4e33 --- /dev/null +++ b/tests/unit_node/tls_test.ts @@ -0,0 +1,150 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import { assertEquals, assertInstanceOf } from "@test_util/std/assert/mod.ts"; +import { delay } from "@test_util/std/async/delay.ts"; +import { fromFileUrl, join } from "@test_util/std/path/mod.ts"; +import { serveTls } from "@test_util/std/http/server.ts"; +import * as tls from "node:tls"; +import * as net from "node:net"; +import * as stream from "node:stream"; + +const tlsTestdataDir = fromFileUrl( + new URL("../testdata/tls", import.meta.url), +); +const keyFile = join(tlsTestdataDir, "localhost.key"); +const certFile = join(tlsTestdataDir, "localhost.crt"); +const key = await Deno.readTextFile(keyFile); +const cert = await Deno.readTextFile(certFile); +const rootCaCert = await Deno.readTextFile(join(tlsTestdataDir, "RootCA.pem")); + +Deno.test("tls.connect makes tls connection", async () => { + const ctl = new AbortController(); + const serve = serveTls(() => new Response("hello"), { + port: 8443, + key, + cert, + signal: ctl.signal, + }); + + await delay(200); + + const conn = tls.connect({ + host: "localhost", + port: 8443, + secureContext: { + ca: rootCaCert, + // deno-lint-ignore no-explicit-any + } as any, + }); + conn.write(`GET / HTTP/1.1 +Host: localhost +Connection: close + +`); + conn.on("data", (chunk) => { + const text = new TextDecoder().decode(chunk); + const bodyText = text.split("\r\n\r\n").at(-1)?.trim(); + assertEquals(bodyText, "hello"); + conn.destroy(); + ctl.abort(); + }); + + await serve; +}); + +// https://github.com/denoland/deno/pull/20120 +Deno.test("tls.connect mid-read tcp->tls upgrade", async () => { + const ctl = new AbortController(); + const serve = serveTls(() => new Response("hello"), { + port: 8443, + key, + cert, + signal: ctl.signal, + }); + + await delay(200); + + const conn = tls.connect({ + host: "localhost", + port: 8443, + secureContext: { + ca: rootCaCert, + // deno-lint-ignore no-explicit-any + } as any, + }); + + conn.setEncoding("utf8"); + conn.write(`GET / HTTP/1.1\nHost: www.google.com\n\n`); + + conn.on("data", (_) => { + conn.destroy(); + ctl.abort(); + }); + + await serve; +}); + +Deno.test("tls.createServer creates a TLS server", async () => { + const deferred = Promise.withResolvers<void>(); + const server = tls.createServer( + // deno-lint-ignore no-explicit-any + { host: "0.0.0.0", key, cert } as any, + (socket: net.Socket) => { + socket.write("welcome!\n"); + socket.setEncoding("utf8"); + socket.pipe(socket).on("data", (data) => { + if (data.toString().trim() === "goodbye") { + socket.destroy(); + } + }); + }, + ); + server.listen(0, async () => { + const conn = await Deno.connectTls({ + hostname: "127.0.0.1", + // deno-lint-ignore no-explicit-any + port: (server.address() as any).port, + caCerts: [rootCaCert], + }); + + const buf = new Uint8Array(100); + await conn.read(buf); + let text: string; + text = new TextDecoder().decode(buf); + assertEquals(text.replaceAll("\0", ""), "welcome!\n"); + buf.fill(0); + + await conn.write(new TextEncoder().encode("hey\n")); + await conn.read(buf); + text = new TextDecoder().decode(buf); + assertEquals(text.replaceAll("\0", ""), "hey\n"); + buf.fill(0); + + await conn.write(new TextEncoder().encode("goodbye\n")); + await conn.read(buf); + text = new TextDecoder().decode(buf); + assertEquals(text.replaceAll("\0", ""), "goodbye\n"); + + conn.close(); + server.close(); + deferred.resolve(); + }); + await deferred.promise; +}); + +Deno.test("TLSSocket can construct without options", () => { + // deno-lint-ignore no-explicit-any + new tls.TLSSocket(new stream.PassThrough() as any); +}); + +Deno.test("tlssocket._handle._parentWrap is set", () => { + // Note: This feature is used in popular 'http2-wrapper' module + // https://github.com/szmarczak/http2-wrapper/blob/51eeaf59ff9344fb192b092241bfda8506983620/source/utils/js-stream-socket.js#L6 + const parentWrap = + // deno-lint-ignore no-explicit-any + ((new tls.TLSSocket(new stream.PassThrough() as any, {}) as any) + // deno-lint-ignore no-explicit-any + ._handle as any)! + ._parentWrap; + assertInstanceOf(parentWrap, stream.PassThrough); +}); diff --git a/tests/unit_node/tty_test.ts b/tests/unit_node/tty_test.ts new file mode 100644 index 000000000..43beda4bc --- /dev/null +++ b/tests/unit_node/tty_test.ts @@ -0,0 +1,36 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +// deno-lint-ignore-file no-explicit-any + +import { assert } from "@test_util/std/assert/mod.ts"; +import { isatty } from "node:tty"; +import process from "node:process"; + +Deno.test("[node/tty isatty] returns true when fd is a tty, false otherwise", () => { + assert(Deno.stdin.isTerminal() === isatty(Deno.stdin.rid)); + assert(Deno.stdout.isTerminal() === isatty(Deno.stdout.rid)); + assert(Deno.stderr.isTerminal() === isatty(Deno.stderr.rid)); + + using file = Deno.openSync("README.md"); + assert(!isatty(file.rid)); +}); + +Deno.test("[node/tty isatty] returns false for irrelevant values", () => { + // invalid numeric fd + assert(!isatty(1234567)); + + // TODO(kt3k): Enable this test when the below issue resolved + // https://github.com/denoland/deno/issues/14398 + // assert(!isatty(-1)); + + // invalid type fd + assert(!isatty("abc" as any)); + assert(!isatty({} as any)); + assert(!isatty([] as any)); + assert(!isatty(null as any)); + assert(!isatty(undefined as any)); +}); + +Deno.test("[node/tty WriteStream.isTTY] returns true when fd is a tty", () => { + assert(Deno.stdin.isTerminal() === process.stdin.isTTY); + assert(Deno.stdout.isTerminal() === process.stdout.isTTY); +}); diff --git a/tests/unit_node/util_test.ts b/tests/unit_node/util_test.ts new file mode 100644 index 000000000..8480266c1 --- /dev/null +++ b/tests/unit_node/util_test.ts @@ -0,0 +1,317 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import { + assert, + assertEquals, + assertStrictEquals, + assertThrows, +} from "@test_util/std/assert/mod.ts"; +import { stripColor } from "@test_util/std/fmt/colors.ts"; +import * as util from "node:util"; +import { Buffer } from "node:buffer"; + +Deno.test({ + name: "[util] format", + fn() { + assertEquals(util.format("%o", [10, 11]), "[ 10, 11, [length]: 2 ]"); + }, +}); + +Deno.test({ + name: "[util] inspect.custom", + fn() { + assertEquals(util.inspect.custom, Symbol.for("nodejs.util.inspect.custom")); + }, +}); + +Deno.test({ + name: "[util] inspect", + fn() { + assertEquals(stripColor(util.inspect({ foo: 123 })), "{ foo: 123 }"); + assertEquals(stripColor(util.inspect("foo")), "'foo'"); + assertEquals( + stripColor(util.inspect("Deno's logo is so cute.")), + `"Deno's logo is so cute."`, + ); + assertEquals( + stripColor(util.inspect([1, 2, 3, 4, 5, 6, 7])), + `[ + 1, 2, 3, 4, + 5, 6, 7 +]`, + ); + }, +}); + +Deno.test({ + name: "[util] isBoolean", + fn() { + assert(util.isBoolean(true)); + assert(!util.isBoolean(new Boolean())); + assert(!util.isBoolean(new Boolean(true))); + assert(util.isBoolean(false)); + assert(!util.isBoolean("deno")); + assert(!util.isBoolean("true")); + }, +}); + +Deno.test({ + name: "[util] isNull", + fn() { + let n; + assert(util.isNull(null)); + assert(!util.isNull(n)); + assert(!util.isNull(0)); + assert(!util.isNull({})); + }, +}); + +Deno.test({ + name: "[util] isNullOrUndefined", + fn() { + let n; + assert(util.isNullOrUndefined(null)); + assert(util.isNullOrUndefined(n)); + assert(!util.isNullOrUndefined({})); + assert(!util.isNullOrUndefined("undefined")); + }, +}); + +Deno.test({ + name: "[util] isNumber", + fn() { + assert(util.isNumber(666)); + assert(!util.isNumber(new Number(666))); + assert(!util.isNumber("999")); + assert(!util.isNumber(null)); + }, +}); + +Deno.test({ + name: "[util] isString", + fn() { + assert(util.isString("deno")); + assert(!util.isString(new String("DIO"))); + assert(!util.isString(1337)); + }, +}); + +Deno.test({ + name: "[util] isSymbol", + fn() { + assert(util.isSymbol(Symbol())); + assert(!util.isSymbol(Object(Symbol()))); + assert(!util.isSymbol(123)); + assert(!util.isSymbol("string")); + }, +}); + +Deno.test({ + name: "[util] isUndefined", + fn() { + let t; + assert(util.isUndefined(t)); + assert(!util.isUndefined("undefined")); + assert(!util.isUndefined({})); + }, +}); + +Deno.test({ + name: "[util] isObject", + fn() { + const dio = { stand: "Za Warudo" }; + assert(util.isObject(dio)); + assert(util.isObject(new RegExp(/Toki Wo Tomare/))); + assert(!util.isObject("Jotaro")); + }, +}); + +Deno.test({ + name: "[util] isError", + fn() { + const java = new Error(); + const nodejs = Reflect.construct(Error, [], Object); + const bun = new DOMException(); + const deno = "Future"; + assert(util.isError(java)); + assert(util.isError(nodejs)); + assert(util.isError(bun)); + assert(!util.isError(deno)); + }, +}); + +Deno.test({ + name: "[util] isFunction", + fn() { + const f = function () {}; + assert(util.isFunction(f)); + assert(!util.isFunction({})); + assert(!util.isFunction(new RegExp(/f/))); + }, +}); + +Deno.test({ + name: "[util] isRegExp", + fn() { + assert(util.isRegExp(new RegExp(/f/))); + assert(util.isRegExp(/fuManchu/)); + assert(!util.isRegExp({ evil: "eye" })); + assert(!util.isRegExp(null)); + }, +}); + +Deno.test({ + name: "[util] isArray", + fn() { + assert(util.isArray([])); + assert(!util.isArray({ yaNo: "array" })); + assert(!util.isArray(null)); + }, +}); + +Deno.test({ + name: "[util] isPrimitive", + fn() { + const stringType = "hasti"; + const booleanType = true; + const integerType = 2; + const symbolType = Symbol("anything"); + + const functionType = function doBest() {}; + const objectType = { name: "ali" }; + const arrayType = [1, 2, 3]; + + assert(util.isPrimitive(stringType)); + assert(util.isPrimitive(booleanType)); + assert(util.isPrimitive(integerType)); + assert(util.isPrimitive(symbolType)); + assert(util.isPrimitive(null)); + assert(util.isPrimitive(undefined)); + assert(!util.isPrimitive(functionType)); + assert(!util.isPrimitive(arrayType)); + assert(!util.isPrimitive(objectType)); + }, +}); + +Deno.test({ + name: "[util] isDate", + fn() { + // Test verifies the method is exposed. See _util/_util_types_test for details + assert(util.isDate(new Date())); + }, +}); + +Deno.test({ + name: "[util] isBuffer", + fn() { + assert(util.isBuffer(new Buffer(4))); + assert(!util.isBuffer(new Uint8Array(4))); + }, +}); + +Deno.test({ + name: "[util] types.isTypedArray", + fn() { + assert(util.types.isTypedArray(new Buffer(4))); + assert(util.types.isTypedArray(new Uint8Array(4))); + assert(!util.types.isTypedArray(new DataView(new ArrayBuffer(4)))); + }, +}); + +Deno.test({ + name: "[util] types.isNativeError", + fn() { + assert(util.types.isNativeError(new Error())); + assert(util.types.isNativeError(new TypeError())); + assert(!util.types.isNativeError(new DOMException())); + }, +}); + +Deno.test({ + name: "[util] TextDecoder", + fn() { + assert(util.TextDecoder === TextDecoder); + const td: util.TextDecoder = new util.TextDecoder(); + assert(td instanceof TextDecoder); + }, +}); + +Deno.test({ + name: "[util] TextEncoder", + fn() { + assert(util.TextEncoder === TextEncoder); + const te: util.TextEncoder = new util.TextEncoder(); + assert(te instanceof TextEncoder); + }, +}); + +Deno.test({ + name: "[util] toUSVString", + fn() { + assertEquals(util.toUSVString("foo"), "foo"); + assertEquals(util.toUSVString("bar\ud801"), "bar\ufffd"); + }, +}); + +Deno.test({ + name: "[util] getSystemErrorName()", + fn() { + type FnTestInvalidArg = (code?: unknown) => void; + + assertThrows( + () => (util.getSystemErrorName as FnTestInvalidArg)(), + TypeError, + ); + assertThrows( + () => (util.getSystemErrorName as FnTestInvalidArg)(1), + RangeError, + ); + + assertStrictEquals(util.getSystemErrorName(-424242), undefined); + + switch (Deno.build.os) { + case "windows": + assertStrictEquals(util.getSystemErrorName(-4091), "EADDRINUSE"); + break; + + case "darwin": + assertStrictEquals(util.getSystemErrorName(-48), "EADDRINUSE"); + break; + + case "linux": + assertStrictEquals(util.getSystemErrorName(-98), "EADDRINUSE"); + break; + } + }, +}); + +Deno.test({ + name: "[util] deprecate() works", + fn() { + const fn = util.deprecate(() => {}, "foo"); + fn(); + }, +}); + +Deno.test({ + name: "[util] callbackify() works", + fn() { + const fn = util.callbackify(() => Promise.resolve("foo")); + fn((err, value) => { + assert(err === null); + assert(value === "foo"); + }); + }, +}); + +Deno.test({ + name: "[util] callbackify(undefined) throws", + fn() { + assertThrows( + // @ts-expect-error: testing runtime error + () => util.callbackify(undefined), + TypeError, + 'The "original" argument must be of type function', + ); + }, +}); diff --git a/tests/unit_node/v8_test.ts b/tests/unit_node/v8_test.ts new file mode 100644 index 000000000..e48285d4e --- /dev/null +++ b/tests/unit_node/v8_test.ts @@ -0,0 +1,55 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { + cachedDataVersionTag, + getHeapStatistics, + setFlagsFromString, +} from "node:v8"; +import { assertEquals } from "@test_util/std/assert/mod.ts"; + +// https://github.com/nodejs/node/blob/a2bbe5ff216bc28f8dac1c36a8750025a93c3827/test/parallel/test-v8-version-tag.js#L6 +Deno.test({ + name: "cachedDataVersionTag success", + fn() { + const tag = cachedDataVersionTag(); + assertEquals(typeof tag, "number"); + assertEquals(cachedDataVersionTag(), tag); + }, +}); + +// https://github.com/nodejs/node/blob/a2bbe5ff216bc28f8dac1c36a8750025a93c3827/test/parallel/test-v8-stats.js#L6 +Deno.test({ + name: "getHeapStatistics success", + fn() { + const s = getHeapStatistics(); + const keys = [ + "does_zap_garbage", + "external_memory", + "heap_size_limit", + "malloced_memory", + "number_of_detached_contexts", + "number_of_native_contexts", + "peak_malloced_memory", + "total_available_size", + "total_global_handles_size", + "total_heap_size", + "total_heap_size_executable", + "total_physical_size", + "used_global_handles_size", + "used_heap_size", + ]; + assertEquals(Object.keys(s).sort(), keys); + for (const k of keys) { + assertEquals( + typeof (s as unknown as Record<string, unknown>)[k], + "number", + ); + } + }, +}); + +Deno.test({ + name: "setFlagsFromString", + fn() { + setFlagsFromString("--allow_natives_syntax"); + }, +}); diff --git a/tests/unit_node/vm_test.ts b/tests/unit_node/vm_test.ts new file mode 100644 index 000000000..30449a7b1 --- /dev/null +++ b/tests/unit_node/vm_test.ts @@ -0,0 +1,66 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +import { isContext, runInNewContext } from "node:vm"; +import { assertEquals, assertThrows } from "@test_util/std/assert/mod.ts"; + +Deno.test({ + name: "vm runInNewContext", + fn() { + const two = runInNewContext("1 + 1"); + assertEquals(two, 2); + }, +}); + +Deno.test({ + name: "vm runInNewContext sandbox", + fn() { + assertThrows(() => runInNewContext("Deno")); + // deno-lint-ignore no-var + var a = 1; + assertThrows(() => runInNewContext("a + 1")); + + runInNewContext("a = 2"); + assertEquals(a, 1); + }, +}); + +// https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/javascript/JavascriptParser.js#L4329 +Deno.test({ + name: "vm runInNewContext webpack magic comments", + fn() { + const webpackCommentRegExp = new RegExp( + /(^|\W)webpack[A-Z]{1,}[A-Za-z]{1,}:/, + ); + const comments = [ + 'webpackChunkName: "test"', + 'webpackMode: "lazy"', + "webpackPrefetch: true", + "webpackPreload: true", + "webpackProvidedExports: true", + 'webpackChunkLoading: "require"', + 'webpackExports: ["default", "named"]', + ]; + + for (const comment of comments) { + const result = webpackCommentRegExp.test(comment); + assertEquals(result, true); + + const [[key, _value]]: [string, string][] = Object.entries( + runInNewContext(`(function(){return {${comment}};})()`), + ); + const expectedKey = comment.split(":")[0].trim(); + assertEquals(key, expectedKey); + } + }, +}); + +Deno.test({ + name: "vm isContext", + fn() { + // Currently we do not expose VM contexts so this is always false. + const obj = {}; + assertEquals(isContext(obj), false); + assertEquals(isContext(globalThis), false); + const sandbox = runInNewContext("{}"); + assertEquals(isContext(sandbox), false); + }, +}); diff --git a/tests/unit_node/worker_threads_test.ts b/tests/unit_node/worker_threads_test.ts new file mode 100644 index 000000000..e79049229 --- /dev/null +++ b/tests/unit_node/worker_threads_test.ts @@ -0,0 +1,204 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import { + assert, + assertEquals, + assertObjectMatch, +} from "@test_util/std/assert/mod.ts"; +import { fromFileUrl, relative } from "@test_util/std/path/mod.ts"; +import * as workerThreads from "node:worker_threads"; +import { EventEmitter, once } from "node:events"; + +Deno.test("[node/worker_threads] BroadcastChannel is exported", () => { + assertEquals<unknown>(workerThreads.BroadcastChannel, BroadcastChannel); +}); + +Deno.test("[node/worker_threads] MessageChannel are MessagePort are exported", () => { + assertEquals<unknown>(workerThreads.MessageChannel, MessageChannel); + assertEquals<unknown>(workerThreads.MessagePort, MessagePort); +}); + +Deno.test({ + name: "[worker_threads] isMainThread", + fn() { + assertEquals(workerThreads.isMainThread, true); + }, +}); + +Deno.test({ + name: "[worker_threads] threadId", + fn() { + assertEquals(workerThreads.threadId, 0); + }, +}); + +Deno.test({ + name: "[worker_threads] resourceLimits", + fn() { + assertObjectMatch(workerThreads.resourceLimits, {}); + }, +}); + +Deno.test({ + name: "[worker_threads] parentPort", + fn() { + assertEquals(workerThreads.parentPort, null); + }, +}); + +Deno.test({ + name: "[worker_threads] workerData", + fn() { + assertEquals(workerThreads.workerData, null); + }, +}); + +Deno.test({ + name: "[worker_threads] setEnvironmentData / getEnvironmentData", + fn() { + workerThreads.setEnvironmentData("test", "test"); + assertEquals(workerThreads.getEnvironmentData("test"), "test"); + }, +}); + +Deno.test({ + name: "[worker_threads] Worker threadId", + async fn() { + const worker = new workerThreads.Worker( + new URL("./testdata/worker_threads.mjs", import.meta.url), + ); + worker.postMessage("Hello, how are you my thread?"); + await once(worker, "message"); + const message = await once(worker, "message"); + assertEquals(message[0].threadId, 1); + worker.terminate(); + + const worker1 = new workerThreads.Worker( + new URL("./testdata/worker_threads.mjs", import.meta.url), + ); + worker1.postMessage("Hello, how are you my thread?"); + await once(worker1, "message"); + assertEquals((await once(worker1, "message"))[0].threadId, 2); + worker1.terminate(); + }, +}); + +Deno.test({ + name: "[worker_threads] Worker basics", + async fn() { + workerThreads.setEnvironmentData("test", "test"); + workerThreads.setEnvironmentData(1, { + test: "random", + random: "test", + }); + const { port1 } = new MessageChannel(); + const worker = new workerThreads.Worker( + new URL("./testdata/worker_threads.mjs", import.meta.url), + { + workerData: ["hey", true, false, 2, port1], + // deno-lint-ignore no-explicit-any + transferList: [port1 as any], + }, + ); + worker.postMessage("Hello, how are you my thread?"); + assertEquals((await once(worker, "message"))[0], "I'm fine!"); + const data = (await once(worker, "message"))[0]; + // data.threadId can be 1 when this test is run individually + if (data.threadId === 1) data.threadId = 3; + assertObjectMatch(data, { + isMainThread: false, + threadId: 3, + workerData: ["hey", true, false, 2], + envData: ["test", { test: "random", random: "test" }], + }); + worker.terminate(); + }, + sanitizeResources: false, +}); + +Deno.test({ + name: "[worker_threads] Worker eval", + async fn() { + const worker = new workerThreads.Worker( + ` + import { parentPort } from "node:worker_threads"; + parentPort.postMessage("It works!"); + `, + { + eval: true, + }, + ); + assertEquals((await once(worker, "message"))[0], "It works!"); + worker.terminate(); + }, +}); + +Deno.test({ + name: "[worker_threads] worker thread with type module", + fn() { + const worker = new workerThreads.Worker( + new URL("./testdata/worker_module/index.js", import.meta.url), + ); + worker.terminate(); + }, +}); + +Deno.test({ + name: "[worker_threads] inheritances", + async fn() { + const worker = new workerThreads.Worker( + ` + import { EventEmitter } from "node:events"; + import { parentPort } from "node:worker_threads"; + parentPort.postMessage(parentPort instanceof EventTarget); + await new Promise(resolve => setTimeout(resolve, 100)); + parentPort.postMessage(parentPort instanceof EventEmitter); + `, + { + eval: true, + }, + ); + assertEquals((await once(worker, "message"))[0], true); + assertEquals((await once(worker, "message"))[0], false); + assert(worker instanceof EventEmitter); + assert(!(worker instanceof EventTarget)); + worker.terminate(); + }, +}); + +Deno.test({ + name: "[worker_threads] Worker workerData", + async fn() { + const worker = new workerThreads.Worker( + new URL("./testdata/worker_threads.mjs", import.meta.url), + { + workerData: null, + }, + ); + worker.postMessage("Hello, how are you my thread?"); + await once(worker, "message"); + assertEquals((await once(worker, "message"))[0].workerData, null); + worker.terminate(); + + const worker1 = new workerThreads.Worker( + new URL("./testdata/worker_threads.mjs", import.meta.url), + ); + worker1.postMessage("Hello, how are you my thread?"); + await once(worker1, "message"); + assertEquals((await once(worker1, "message"))[0].workerData, undefined); + worker1.terminate(); + }, +}); + +Deno.test({ + name: "[worker_threads] Worker with relative path", + async fn() { + const worker = new workerThreads.Worker(relative( + Deno.cwd(), + fromFileUrl(new URL("./testdata/worker_threads.mjs", import.meta.url)), + )); + worker.postMessage("Hello, how are you my thread?"); + assertEquals((await once(worker, "message"))[0], "I'm fine!"); + worker.terminate(); + }, +}); diff --git a/tests/unit_node/zlib_test.ts b/tests/unit_node/zlib_test.ts new file mode 100644 index 000000000..31ebe0b4f --- /dev/null +++ b/tests/unit_node/zlib_test.ts @@ -0,0 +1,172 @@ +// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. + +import { assert, assertEquals } from "@test_util/std/assert/mod.ts"; +import { fromFileUrl, relative } from "@test_util/std/path/mod.ts"; +import { + brotliCompress, + brotliCompressSync, + brotliDecompressSync, + createBrotliCompress, + createBrotliDecompress, + createDeflate, + gzipSync, + unzipSync, +} from "node:zlib"; +import { Buffer } from "node:buffer"; +import { createReadStream, createWriteStream } from "node:fs"; +import { Readable } from "node:stream"; +import { buffer } from "node:stream/consumers"; + +Deno.test("brotli compression sync", () => { + const buf = Buffer.from("hello world"); + const compressed = brotliCompressSync(buf); + const decompressed = brotliDecompressSync(compressed); + assertEquals(decompressed.toString(), "hello world"); +}); + +Deno.test("brotli compression async", async () => { + const buf = Buffer.from("hello world"); + const compressed: Buffer = await new Promise((resolve) => + brotliCompress(buf, (_, res) => { + return resolve(res); + }) + ); + assertEquals(compressed instanceof Buffer, true); + const decompressed = brotliDecompressSync(compressed); + assertEquals(decompressed.toString(), "hello world"); +}); + +Deno.test("gzip compression sync", { sanitizeResources: false }, () => { + const buf = Buffer.from("hello world"); + const compressed = gzipSync(buf); + const decompressed = unzipSync(compressed); + assertEquals(decompressed.toString(), "hello world"); +}); + +Deno.test("brotli compression", async () => { + const { promise, resolve } = Promise.withResolvers<void>(); + const compress = createBrotliCompress(); + const filePath = relative( + Deno.cwd(), + fromFileUrl(new URL("./testdata/lorem_ipsum.txt", import.meta.url)), + ); + const input = createReadStream(filePath); + const output = createWriteStream("lorem_ipsum.txt.br"); + + const stream = input.pipe(compress).pipe(output); + + stream.on("finish", () => { + const decompress = createBrotliDecompress(); + const input2 = createReadStream("lorem_ipsum.txt.br"); + const output2 = createWriteStream("lorem_ipsum.txt"); + + const stream2 = input2.pipe(decompress).pipe(output2); + + stream2.on("finish", () => { + resolve(); + }); + }); + + await promise; + const content = Deno.readTextFileSync("lorem_ipsum.txt"); + assert(content.startsWith("Lorem ipsum dolor sit amet")); + try { + Deno.removeSync("lorem_ipsum.txt.br"); + } catch { + // pass + } + try { + Deno.removeSync("lorem_ipsum.txt"); + } catch { + // pass + } +}); + +Deno.test("brotli end-to-end with 4097 bytes", () => { + const a = "a".repeat(4097); + const compressed = brotliCompressSync(a); + const decompressed = brotliDecompressSync(compressed); + assertEquals(decompressed.toString(), a); +}); + +Deno.test( + "zlib create deflate with dictionary", + { sanitizeResources: false }, + async () => { + const { promise, resolve } = Promise.withResolvers<void>(); + const handle = createDeflate({ + dictionary: Buffer.alloc(0), + }); + + handle.on("close", () => resolve()); + handle.end(); + handle.destroy(); + + await promise; + }, +); + +Deno.test( + "zlib flush i32", + // FIXME: Handle is not closed properly + { sanitizeResources: false }, + function () { + const handle = createDeflate({ + // @ts-expect-error: passing non-int flush value + flush: "", + }); + + handle.end(); + handle.destroy(); + }, +); + +Deno.test("should work with dataview", () => { + const buf = Buffer.from("hello world"); + const compressed = brotliCompressSync(new DataView(buf.buffer)); + const decompressed = brotliDecompressSync(compressed); + assertEquals(decompressed.toString(), "hello world"); +}); + +Deno.test("should work with a buffer from an encoded string", () => { + const encoder = new TextEncoder(); + const buffer = encoder.encode("hello world"); + const buf = Buffer.from(buffer); + const compressed = brotliCompressSync(buf); + const decompressed = brotliDecompressSync(compressed); + assertEquals(decompressed.toString(), "hello world"); +}); + +Deno.test( + "zlib compression with dataview", + { sanitizeResources: false }, + () => { + const buf = Buffer.from("hello world"); + const compressed = gzipSync(new DataView(buf.buffer)); + const decompressed = unzipSync(compressed); + assertEquals(decompressed.toString(), "hello world"); + }, +); + +Deno.test("zlib compression with an encoded string", { + sanitizeResources: false, +}, () => { + const encoder = new TextEncoder(); + const buffer = encoder.encode("hello world"); + const compressed = gzipSync(buffer); + const decompressed = unzipSync(compressed); + assertEquals(decompressed.toString(), "hello world"); +}); + +Deno.test("brotli large chunk size", async () => { + const input = new Uint8Array(1000000); + for (let i = 0; i < input.length; i++) { + input[i] = Math.random() * 256; + } + const output = await buffer( + Readable.from([input]) + .pipe(createBrotliCompress()) + .pipe(createBrotliDecompress()), + ); + assertEquals(output.length, input.length); +}); |