orgnote-api 0.14.2 → 0.15.1

package/encryption/__tests__/__snapshots__/note-encryption.spec.ts.snap

@@ -4,7 +4,6 @@ exports[`Should decrypt note content via password 1`] = `
 [
   {
     "encrypted": false,
-    "encryptionType": "gpgPassword",
     "id": "id",
     "meta": {
       "headings": [
@@ -28,7 +27,6 @@ exports[`Should decrypt note via provided keys 1`] = `
 [
   {
     "encrypted": false,
-    "encryptionType": "gpgKeys",
     "id": "id",
     "meta": {
       "headings": [
@@ -48,6 +46,22 @@ exports[`Should decrypt note via provided keys 1`] = `
 ]
 `;
 
+exports[`Should encrypt note and decrypt it into binary format 1`] = `
+{
+  "author": {
+    "email": "test@mail.com",
+    "id": "1",
+    "name": "John Doe",
+  },
+  "encrypted": true,
+  "id": "id",
+  "meta": {
+    "id": undefined,
+    "published": false,
+  },
+}
+`;
+
 exports[`Should encrypt note content via password 1`] = `
 {
   "author": {
@@ -56,7 +70,38 @@ exports[`Should encrypt note content via password 1`] = `
     "name": "John Doe",
   },
   "encrypted": true,
-  "encryptionType": "gpgPassword",
+  "id": "id",
+  "meta": {
+    "id": undefined,
+    "published": false,
+  },
+}
+`;
+
+exports[`Should encrypt note content via password to binary format 1`] = `
+{
+  "author": {
+    "email": "test@mail.com",
+    "id": "1",
+    "name": "John Doe",
+  },
+  "encrypted": true,
+  "id": "id",
+  "meta": {
+    "id": undefined,
+    "published": false,
+  },
+}
+`;
+
+exports[`Should encrypt note to binary format 1`] = `
+{
+  "author": {
+    "email": "test@mail.com",
+    "id": "1",
+    "name": "John Doe",
+  },
+  "encrypted": true,
   "id": "id",
   "meta": {
     "id": undefined,
@@ -73,7 +118,6 @@ exports[`Should encrypt note via keys 1`] = `
     "name": "John Doe",
   },
   "encrypted": true,
-  "encryptionType": "gpgKeys",
   "id": "id",
   "meta": {
     "id": undefined,
@@ -130,7 +174,6 @@ exports[`Should not encrypt public note 1`] = `
     "name": "John Doe",
   },
   "encrypted": false,
-  "encryptionType": "gpgPassword",
   "id": "id",
   "meta": {
     "description": "Awesome description",
@@ -145,7 +188,6 @@ exports[`Should set not encrypted status when params type does not provided 1`]
 [
   {
     "encrypted": true,
-    "encryptionType": "gpgKeys",
     "id": "id",
     "meta": {
       "description": "Awesome description",

package/encryption/__tests__/encryption.spec.ts

@@ -8,6 +8,9 @@ import {
   IncorrectOrMissingPrivateKeyPasswordError,
   encrypt,
   decrypt,
+  _encryptViaKeys,
+  armor,
+  unarmor,
 } from '../encryption';
 import { test, expect } from 'vitest';
 
@@ -16,21 +19,35 @@ import {
   armoredPrivateKey,
   privateKeyPassphrase,
 } from './encryption-keys';
+// import { armor } from 'openpgp';
+
+test('Should encrypt text as armored message via keys', async () => {
+  const res = await encryptViaKeys({
+    content: 'Hello world',
+    publicKey: armoredPublicKey,
+    privateKey: armoredPrivateKey,
+    privateKeyPassphrase: privateKeyPassphrase,
+    format: 'armored',
+  });
+
+  expect(res.startsWith('-----BEGIN PGP MESSAGE-----')).toBeTruthy();
+});
 
 test('Should encrypt text via keys', async () => {
-  const res = await encryptViaKeys(
-    'Hello world',
-    armoredPublicKey,
-    armoredPrivateKey,
-    privateKeyPassphrase
-  );
+  const res = await encryptViaKeys({
+    content: 'Hello world',
+    publicKey: armoredPublicKey,
+    privateKey: armoredPrivateKey,
+    privateKeyPassphrase,
+    format: 'armored',
+  });
 
   expect(res.startsWith('-----BEGIN PGP MESSAGE-----')).toBeTruthy();
 });
 
 test('Should decrypt via provided keys', async () => {
-  const decryptedMessage = await decryptViaKeys(
-    `-----BEGIN PGP MESSAGE-----
+  const decryptedMessage = await decryptViaKeys({
+    content: `-----BEGIN PGP MESSAGE-----
 
 wcFMA/vryg+TTn0rARAAhXuEjOHa856iCNVmdeIGHF+IEoeEwTc5tIcr6Lri
 V6xs//3WnwVwUlyxYrum3yCpx8t5gyWTXFfTNH08VoVqPVP45fkk1H7jdC6Q
@@ -62,15 +79,19 @@ YQ==
 =f4F1
 -----END PGP MESSAGE-----
 `,
-    armoredPrivateKey,
-    privateKeyPassphrase
-  );
+    privateKey: armoredPrivateKey,
+    privateKeyPassphrase,
+  });
   expect(decryptedMessage).toEqual('Hello world');
 });
 
 test('Should encrypt via password', async () => {
   const password = 'test';
-  const res = await encryptViaPassword('Hello world', password);
+  const res = await encryptViaPassword({
+    content: 'Hello world',
+    password,
+    format: 'armored',
+  });
 
   expect(res.startsWith('-----BEGIN PGP MESSAGE-----')).toBeTruthy();
 });
@@ -86,7 +107,7 @@ aGW80jwBXEQ7uTjT8akpOKiH7BIuhEUZIXh+vDveG0Uwf63s2dIklznAEo+E
 -----END PGP MESSAGE-----
 `;
 
-  expect(await decryptViaPassword(encryptedMsg, password)).toEqual(
+  expect(await decryptViaPassword({ content: encryptedMsg, password })).toEqual(
     'Hello world'
   );
 });
@@ -125,14 +146,13 @@ YQ==
 -----END PGP MESSAGE-----`;
 
   try {
-    await decryptViaPassword(encryptedMsg, 'password');
+    await decryptViaPassword({ content: encryptedMsg, password: 'password' });
   } catch (e) {
     expect(e).toBeInstanceOf(NoKeysProvidedError);
   }
 });
 
 test('Should raise IncorrectOrMissingPrivateKeyPasswordError error when incorrect armored key provided', async () => {
-  const password = 'test';
   const encryptedMsg = `-----BEGIN PGP MESSAGE-----
 
 wy4ECQMI6KFWGqyVV+DgYl0qUEeTe1kAdjkoR4FxFJxx+6QiOP+sZ6h7bn//
@@ -143,7 +163,11 @@ aGW80jwBXEQ7uTjT8akpOKiH7BIuhEUZIXh+vDveG0Uwf63s2dIklznAEo+E
 `;
 
   try {
-    await decryptViaKeys(encryptedMsg, armoredPublicKey, privateKeyPassphrase);
+    await decryptViaKeys({
+      content: encryptedMsg,
+      publicKey: armoredPublicKey,
+      privateKey: privateKeyPassphrase,
+    });
   } catch (e) {
     expect(e).toBeInstanceOf(IncorrectOrMissingPrivateKeyPasswordError);
   }
@@ -160,7 +184,11 @@ aGW80jwBXEQ7uTjT8akpOKiH7BIuhEUZIXh+vDveG0Uwf63s2dIklznAEo+E
 `;
 
   try {
-    await decryptViaKeys(encryptedMsg, armoredPrivateKey, privateKeyPassphrase);
+    await decryptViaKeys({
+      content: encryptedMsg,
+      privateKey: armoredPrivateKey,
+      privateKeyPassphrase,
+    });
   } catch (e) {
     expect(e).toBeInstanceOf(NoPasswordProvidedError);
   }
@@ -170,14 +198,17 @@ test('Should encrypt and decrypt text by provided configs via password', async (
   const text = 'Hello world';
   const password = '123';
 
-  const res = await encrypt(text, {
+  const res = await encrypt({
+    content: text,
     type: 'gpgPassword',
     password,
+    format: 'armored',
   });
 
   expect(res.startsWith('-----BEGIN PGP MESSAGE-----')).toBeTruthy();
 
-  const decryptedMessage = await decrypt(res, {
+  const decryptedMessage = await decrypt({
+    content: res,
     type: 'gpgPassword',
     password,
   });
@@ -187,8 +218,10 @@ test('Should encrypt and decrypt text by provided configs via password', async (
 
 test('Should encrypt and decrypt text by provided configs via keys', async () => {
   const text = 'Hello world';
-  const res = await encrypt(text, {
+  const res = await encrypt({
+    content: text,
     type: 'gpgKeys',
+    format: 'armored',
     publicKey: armoredPublicKey,
     privateKey: armoredPrivateKey,
     privateKeyPassphrase,
@@ -196,12 +229,103 @@ test('Should encrypt and decrypt text by provided configs via keys', async () =>
 
   expect(res.startsWith('-----BEGIN PGP MESSAGE-----')).toBeTruthy();
 
-  const decryptedMessage = await decrypt(res, {
+  const decryptedMessage = await decrypt({
+    content: res,
     type: 'gpgKeys',
     publicKey: armoredPublicKey,
     privateKey: armoredPrivateKey,
     privateKeyPassphrase,
+    format: 'utf8',
+  });
+
+  expect(decryptedMessage).toEqual(text);
+});
+
+test('Should encrypt to binary and decrypt to format armored!', async () => {
+  const text = 'Hello world';
+
+  const res = await encrypt({
+    content: text,
+    type: 'gpgPassword',
+    password: '123',
+    format: 'binary',
+  });
+
+  expect(res).toBeInstanceOf(Uint8Array);
+
+  const decryptedMessage = await decrypt({
+    content: res,
+    type: 'gpgPassword',
+    format: 'utf8',
+    password: '123',
   });
 
   expect(decryptedMessage).toEqual(text);
 });
+
+test('Should encrypt to binary and decrypt to binary format', async () => {
+  const text = 'Hello world';
+
+  const res = await encrypt({
+    content: text,
+    type: 'gpgPassword',
+    password: '123',
+    format: 'binary',
+  });
+
+  expect(res).toBeInstanceOf(Uint8Array);
+
+  const decryptedMessage = await decrypt({
+    content: res,
+    type: 'gpgPassword',
+    format: 'binary',
+    password: '123',
+  });
+
+  expect(decryptedMessage.toString()).toMatchInlineSnapshot(
+    `"72,101,108,108,111,32,119,111,114,108,100"`
+  );
+});
+
+test('Should encrypt to armored text and decrypt as binary format', async () => {
+  const text = 'Hello world';
+
+  const res = await encrypt({
+    content: text,
+    type: 'gpgPassword',
+    password: '123',
+    format: 'armored',
+  });
+
+  expect(res).toBeTypeOf('string');
+
+  const decryptedMessage = await decrypt({
+    content: res,
+    type: 'gpgPassword',
+    format: 'binary',
+    password: '123',
+  });
+
+  expect(decryptedMessage).toBeInstanceOf(Uint8Array);
+});
+
+test('Should armor and unarmor encrypted file', async () => {
+  const content: Uint8Array = new Uint8Array([
+    72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100,
+  ]);
+
+  const armored = armor(content);
+
+  expect(armored).toMatchInlineSnapshot(`
+    "-----BEGIN PGP MESSAGE-----
+
+    SGVsbG8gd29ybGQ=
+    =7asC
+    -----END PGP MESSAGE-----
+    "
+  `);
+
+  const { text, data } = await unarmor(armored);
+
+  expect(data).toEqual(content);
+});

package/encryption/__tests__/note-encryption.spec.ts

@@ -17,7 +17,6 @@ test('Should encrypt note content via password', async () => {
 
   const note: Note = {
     id: 'id',
-    encryptionType: 'gpgPassword',
     meta: {
       title: 'My note title',
       images: [],
@@ -31,9 +30,11 @@ test('Should encrypt note content via password', async () => {
     },
   };
 
-  const [encryptedNote, encryptedNoteText] = await encryptNote(note, noteText, {
+  const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
+    content: noteText,
     type: 'gpgPassword',
     password: '123',
+    format: 'armored',
   });
 
   expect(encryptedNoteText.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(
@@ -42,6 +43,39 @@ test('Should encrypt note content via password', async () => {
   expect(encryptedNote).toMatchSnapshot();
 });
 
+test('Should encrypt note content via password to binary format', async () => {
+  const noteText = `#+ID: qweqwe
+
+#+TITLE: Hello worlld
+
+* Hello?`;
+
+  const note: Note = {
+    id: 'id',
+    meta: {
+      title: 'My note title',
+      images: [],
+      published: false,
+      description: 'Awesome description',
+    },
+    author: {
+      id: '1',
+      name: 'John Doe',
+      email: 'test@mail.com',
+    },
+  };
+
+  const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
+    content: noteText,
+    type: 'gpgPassword',
+    password: '123',
+    format: 'binary',
+  });
+
+  expect(encryptedNote).toMatchSnapshot();
+  expect(encryptedNoteText).toBeInstanceOf(Uint8Array);
+});
+
 test('Should decrypt note content via password', async () => {
   const noteText = `-----BEGIN PGP MESSAGE-----
 
@@ -51,9 +85,9 @@ zt3v0mABvaBJA7corlU8su21TpPApOs/+DMWpVlbI3Zer7QfQK1fSBoSTbCR
 5Bjlwt4ZhxFsh+c=
 =csID
 -----END PGP MESSAGE-----`;
+
   const note: Note = {
     id: 'id',
-    encryptionType: 'gpgPassword',
     meta: {
       title: 'My note title',
       images: [],
@@ -62,7 +96,8 @@ zt3v0mABvaBJA7corlU8su21TpPApOs/+DMWpVlbI3Zer7QfQK1fSBoSTbCR
     },
   };
 
-  const decryptedNote = await decryptNote(note, noteText, {
+  const decryptedNote = await decryptNote(note, {
+    content: noteText,
     type: 'gpgPassword',
     password: '123',
   });
@@ -70,7 +105,7 @@ zt3v0mABvaBJA7corlU8su21TpPApOs/+DMWpVlbI3Zer7QfQK1fSBoSTbCR
   expect(decryptedNote).toMatchSnapshot();
 });
 
-test.skip('Should encrypt note via keys', async () => {
+test('Should encrypt note via keys', async () => {
   const noteText = `#+ID: qweqwe
 #+TITLE: Hello worlld
 
@@ -78,7 +113,6 @@ test.skip('Should encrypt note via keys', async () => {
 
   const note: Note = {
     id: 'id',
-    encryptionType: 'gpgKeys',
     meta: {
       title: 'My note title for encryption via keys',
       images: [],
@@ -92,11 +126,13 @@ test.skip('Should encrypt note via keys', async () => {
     },
   };
 
-  const [encryptedNote, encryptedNoteText] = await encryptNote(note, noteText, {
+  const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
+    content: noteText,
     type: ModelsPublicNoteEncryptionTypeEnum.GpgKeys,
     publicKey: armoredPublicKey,
     privateKey: armoredPrivateKey,
     privateKeyPassphrase,
+    format: 'armored',
   });
 
   expect(encryptedNoteText.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(
@@ -140,7 +176,6 @@ yEN8xpFUs7A9xryVZOosp9Sfe3IbBkO99sAQ7jV4EoMYk3/GKA==
 
   const note: Note = {
     id: 'id',
-    encryptionType: 'gpgKeys',
     meta: {
       title: 'My note title for decryption via keys',
       images: [],
@@ -149,7 +184,8 @@ yEN8xpFUs7A9xryVZOosp9Sfe3IbBkO99sAQ7jV4EoMYk3/GKA==
     },
   };
 
-  const decryptedNote = await decryptNote(note, encryptedNoteText, {
+  const decryptedNote = await decryptNote(note, {
+    content: encryptedNoteText,
     type: 'gpgKeys',
     publicKey: armoredPublicKey,
     privateKey: armoredPrivateKey,
@@ -167,7 +203,6 @@ test('Should not encrypt public note', async () => {
 
   const note: Note = {
     id: 'id',
-    encryptionType: 'gpgPassword',
     meta: {
       title: 'My note title',
       images: [],
@@ -181,9 +216,11 @@ test('Should not encrypt public note', async () => {
     },
   };
 
-  const [encryptedNote, encryptedNoteText] = await encryptNote(note, noteText, {
+  const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
+    content: noteText,
     type: 'gpgPassword',
     password: '123',
+    format: 'armored',
   });
 
   expect(encryptedNoteText.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(
@@ -213,9 +250,11 @@ test('Should encrypt note with empty encrypted property', async () => {
     },
   };
 
-  const [encryptedNote, encryptedNoteText] = await encryptNote(note, noteText, {
+  const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
+    content: noteText,
     type: 'gpgPassword',
     password: '123',
+    format: 'armored',
   });
 
   expect(encryptedNoteText.startsWith('-----BEGIN PGP MESSAGE-----')).toBe(
@@ -246,9 +285,11 @@ test('Should not decrypt note without provided encrypted type', async () => {
     },
   };
 
-  const decryptedInfo = await decryptNote(note, noteText, {
+  const decryptedInfo = await decryptNote(note, {
+    content: noteText,
     type: 'gpgPassword',
     password: '123',
+    format: 'armored',
   });
 
   expect(decryptedInfo).toMatchSnapshot();
@@ -265,7 +306,6 @@ test('Should decrypt note and note meta', async () => {
   const note: Note = {
     id: 'id',
     meta: { ...meta },
-    encryptionType: 'gpgPassword',
   };
 
   const noteText = `#+TITLE: My note title
@@ -277,19 +317,17 @@ test('Should decrypt note and note meta', async () => {
 
 Hello world`;
 
-  const [encryptedNote, encryptedNoteText] = await encryptNote(note, noteText, {
+  const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
+    content: noteText,
     type: 'gpgPassword',
     password: '123',
   });
 
-  const [decryptedNote, decryptedNoteText] = await decryptNote(
-    encryptedNote,
-    encryptedNoteText,
-    {
-      type: 'gpgPassword',
-      password: '123',
-    }
-  );
+  const [decryptedNote, decryptedNoteText] = await decryptNote(encryptedNote, {
+    content: encryptedNoteText,
+    type: 'gpgPassword',
+    password: '123',
+  });
 
   expect(decryptedNote.meta).toEqual(meta);
   expect(decryptedNoteText).toEqual(noteText);
@@ -298,7 +336,6 @@ Hello world`;
 test('Should set not encrypted status when params type does not provided', async () => {
   const note: Note = {
     id: 'id',
-    encryptionType: 'gpgKeys',
     meta: {
       title: 'My note title for decryption via keys',
       images: [],
@@ -339,9 +376,50 @@ yEN8xpFUs7A9xryVZOosp9Sfe3IbBkO99sAQ7jV4EoMYk3/GKA==
 =LjkG
 -----END PGP MESSAGE-----`;
 
-  const decryptedNote = await decryptNote(note, noteText, {
+  const decryptedNote = await decryptNote(note, {
+    content: noteText,
     type: 'disabled',
   });
 
   expect(decryptedNote).toMatchSnapshot();
 });
+
+test('Should encrypt note to binary format', async () => {
+  const noteText = `#+ID: qweqwe
+#+TITLE: Hello worlld
+
+* Hello?`;
+
+  const note: Note = {
+    id: 'id',
+    meta: {
+      title: 'My note title',
+      images: [],
+      published: false,
+      description: 'Awesome description',
+    },
+    author: {
+      id: '1',
+      name: 'John Doe',
+      email: 'test@mail.com',
+    },
+  };
+
+  const [encryptedNote, encryptedNoteText] = await encryptNote(note, {
+    content: noteText,
+    type: 'gpgPassword',
+    password: '123',
+    format: 'binary',
+  });
+
+  expect(encryptedNoteText).toBeInstanceOf(Uint8Array);
+  expect(encryptedNote).toMatchSnapshot();
+
+  const [_, decryptedNoteText] = await decryptNote(encryptedNote, {
+    content: encryptedNoteText,
+    type: 'gpgPassword',
+    password: '123',
+  });
+
+  expect(decryptedNoteText).toEqual(noteText);
+});

package/encryption/encryption.ts

@@ -6,9 +6,16 @@ import {
   readKey,
   readMessage,
   readPrivateKey,
+  Stream,
 } from 'openpgp';
 import { ModelsPublicNoteEncryptionTypeEnum } from '../remote-api';
-import { OrgNoteEncryption } from '../models/encryption';
+import {
+  OrgNoteEncryption,
+  OrgNotePasswordEncryption,
+  WithDecryptionContent,
+} from '../models/encryption';
+import { OrgNoteGpgEncryption, WithEncryptionContent } from 'src/models';
+import { armor as _armor, unarmor as _unarmor, enums } from 'openpgp';
 
 export class IncorrectOrMissingPrivateKeyPasswordError extends Error {}
 export class ImpossibleToDecryptWithProvidedKeysError extends Error {}
@@ -43,74 +50,84 @@ export const encryptViaPassword = withCustomErrors(_encryptViaPassword);
 export const decryptViaPassword = withCustomErrors(_decryptViaPassword);
 export const decryptViaKeys = withCustomErrors(_decryptViaKeys);
 
-export const encrypt = async (
-  text: string,
-  encryptionParams: OrgNoteEncryption
-): Promise<string> => {
+export const encrypt = async <
+  T extends WithEncryptionContent<OrgNoteEncryption>,
+>(
+  encryptionParams: T
+): Promise<T['format'] extends 'binary' ? Uint8Array : string> => {
   if (
     !encryptionParams.type ||
     encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.Disabled
   ) {
-    return text;
+    return encryptionParams.content as any;
   }
-  return encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.GpgKeys
-    ? await encryptViaKeys(
-        text,
-        encryptionParams.publicKey,
-        encryptionParams.privateKey,
-        encryptionParams.privateKeyPassphrase
-      )
-    : await encryptViaPassword(text, encryptionParams.password);
+
+  const res = (encryptionParams.type ===
+  ModelsPublicNoteEncryptionTypeEnum.GpgKeys
+    ? await encryptViaKeys(encryptionParams)
+    : await encryptViaPassword(encryptionParams)) as unknown as Promise<
+    T['format'] extends 'binary' ? Uint8Array : string
+  >;
+
+  return res;
 };
 
-export const decrypt = async (
-  text: string,
-  encryptionParams: OrgNoteEncryption
-): Promise<string> => {
+export const decrypt = async <
+  T extends WithDecryptionContent<OrgNoteEncryption>,
+>(
+  decryptionParams: T
+): Promise<T['format'] extends 'binary' ? Uint8Array : string> => {
   if (
-    !encryptionParams.type ||
-    encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.Disabled
+    !decryptionParams.type ||
+    decryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.Disabled
   ) {
-    return text;
+    return decryptionParams.content as any;
   }
-  const decryptedNote =
-    encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.GpgKeys
-      ? await decryptViaKeys(
-          text,
-          encryptionParams.privateKey,
-          encryptionParams.privateKeyPassphrase
-        )
-      : await decryptViaPassword(text, encryptionParams.password);
+  const decryptedNote = (decryptionParams.type ===
+  ModelsPublicNoteEncryptionTypeEnum.GpgKeys
+    ? await decryptViaKeys(decryptionParams)
+    : await decryptViaPassword(decryptionParams)) as unknown as Promise<
+    T['format'] extends 'binary' ? Uint8Array : string
+  >;
+
   return decryptedNote;
 };
 
-async function _encryptViaPassword(
-  text: string,
-  password: string
-): Promise<string> {
+async function _encryptViaPassword<
+  T extends WithEncryptionContent<OrgNotePasswordEncryption>,
+>({
+  content,
+  password,
+  format = 'binary',
+}: T): Promise<T['format'] extends 'binary' ? Uint8Array : string> {
   const message = await createMessage({
-    text,
+    text: content,
   });
 
   const encryptedMessage = await _encrypt({
     message,
-    format: 'armored',
+    format: format as any,
     passwords: [password],
   });
 
-  return encryptedMessage.toString();
+  return encryptedMessage as Promise<
+    T['format'] extends 'binary' ? Uint8Array : string
+  >;
 }
 
-async function _encryptViaKeys(
-  text: string,
-  armoredPublicKey: string,
-  armoredPrivateKey: string,
-  privateKeyPassphrase?: string
-): Promise<string> {
+export async function _encryptViaKeys<
+  T extends WithEncryptionContent<OrgNoteGpgEncryption>,
+>({
+  content,
+  publicKey: armoredPublicKey,
+  privateKey: armoredPrivateKey,
+  privateKeyPassphrase,
+  format = 'binary',
+}: T): Promise<T['format'] extends 'binary' ? Uint8Array : string> {
   const publicKey = await readKey({ armoredKey: armoredPublicKey });
 
   const message = await createMessage({
-    text,
+    text: content,
   });
 
   const encryptedPrivateKey = await readPrivateKey({
@@ -126,52 +143,73 @@ async function _encryptViaKeys(
 
   const encryptedMessage = await _encrypt({
     message,
-    format: 'armored',
+    format: format as any,
     encryptionKeys: publicKey,
     signingKeys: privateKey,
   });
 
-  return encryptedMessage.toString();
+  return encryptedMessage as Promise<
+    T['format'] extends 'binary' ? Uint8Array : string
+  >;
 }
 
-async function _decryptViaPassword(
-  data: string,
-  password: string
-): Promise<string> {
-  const message = await readMessage({ armoredMessage: data });
+async function _decryptViaPassword<
+  T extends Omit<WithDecryptionContent<OrgNotePasswordEncryption>, 'type'>,
+>({
+  content,
+  password,
+  format = 'utf8',
+}: T): Promise<T['format'] extends 'binary' ? Uint8Array : string> {
+  const isArmoredContent = typeof content === 'string';
+
+  const message = await (isArmoredContent
+    ? readMessage({ armoredMessage: content })
+    : readMessage({ binaryMessage: content }));
 
   const { data: decryptedText } = await _decrypt({
     message,
+    format,
     passwords: password,
   });
 
-  return decryptedText.toString();
+  return decryptedText as Promise<
+    T['format'] extends 'binary' ? Uint8Array : string
+  >;
 }
 
-async function _decryptViaKeys(
-  data: string,
-  armoredPrivateKey: string,
-  privateKeyPassword?: string
-): Promise<string> {
+async function _decryptViaKeys<
+  T extends Omit<WithDecryptionContent<OrgNoteGpgEncryption>, 'type'>,
+>({
+  privateKey: armoredPrivateKey,
+  privateKeyPassphrase,
+  content,
+  format = 'utf8',
+}: T): Promise<T['format'] extends 'binary' ? Uint8Array : string> {
   const encryptedPrivateKey = await readPrivateKey({
     armoredKey: armoredPrivateKey,
   });
 
-  const privateKey = privateKeyPassword
+  const privateKey = privateKeyPassphrase
     ? await decryptKey({
         privateKey: encryptedPrivateKey,
-        passphrase: privateKeyPassword,
+        passphrase: privateKeyPassphrase,
       })
     : encryptedPrivateKey;
 
-  const message = await readMessage({ armoredMessage: data });
+  const isString = typeof content === 'string';
+  const message = await (isString
+    ? readMessage({ armoredMessage: content })
+    : readMessage({ binaryMessage: content }));
 
   const { data: decryptedText } = await _decrypt({
     message,
+    format,
     decryptionKeys: privateKey,
   });
 
-  return decryptedText.toString();
+  return decryptedText as Promise<
+    T['format'] extends 'binary' ? Uint8Array : string
+  >;
 }
 
 function withCustomErrors<P extends unknown[], T>(
@@ -213,3 +251,14 @@ function withCustomErrors<P extends unknown[], T>(
     }
   };
 }
+
+// TODO: feat/native-encryption-support add custom error handling
+export function armor(data: Uint8Array): string {
+  return _armor(enums.armor.message, data);
+}
+
+export async function unarmor(
+  data: string
+): Promise<{ text: string; data: Stream<Uint8Array>; type: enums.armor }> {
+  return await _unarmor(data);
+}

package/encryption/note-encryption.ts

@@ -1,22 +1,16 @@
-import {
-  ModelsPublicNote,
-  ModelsPublicNoteEncryptionTypeEnum,
-} from '../remote-api';
+import { ModelsPublicNoteEncryptionTypeEnum } from '../remote-api';
 
+import { decrypt, encrypt } from './encryption';
 import {
-  decryptViaKeys,
-  decryptViaPassword,
-  encryptViaKeys,
-  encryptViaPassword,
-} from './encryption';
-import { OrgNoteEncryption } from '../models/encryption';
+  OrgNoteEncryption,
+  WithDecryptionContent,
+  WithEncryptionContent,
+  WithNoteDecryptionContent,
+} from '../models/encryption';
 import { parse, withMetaInfo } from 'org-mode-ast';
 import { isGpgEncrypted } from '..';
 
-export type NoteEncryptionType = `${ModelsPublicNote['encryptionType']}`;
-
 export interface AbstractEncryptedNote {
-  encryptionType?: NoteEncryptionType;
   encrypted?: boolean;
   meta: {
     [key: string]: any;
@@ -29,8 +23,7 @@ export type EncryptionResult<T> = Promise<[T, string]>;
 // TODO: master change signature for encrypt notes without content
 export async function encryptNote<T extends AbstractEncryptedNote>(
   note: T,
-  noteText: string,
-  encryptionParams: OrgNoteEncryption
+  encryptionParams: WithEncryptionContent<OrgNoteEncryption>
 ): EncryptionResult<T> {
   note.encrypted = false;
   if (
@@ -38,132 +31,47 @@ export async function encryptNote<T extends AbstractEncryptedNote>(
     encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.Disabled ||
     note.meta.published
   ) {
-    return [note, noteText];
+    return [note, encryptionParams.content];
   }
 
   note.meta = { id: note.meta.id, published: note.meta.published };
 
-  const [encryptedNote, encryptedNoteText] =
-    encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.GpgKeys
-      ? await encryptNoteViaKeys(
-          note,
-          encryptionParams.publicKey,
-          encryptionParams.privateKey,
-          encryptionParams.privateKeyPassphrase
-        )
-      : await encryptNoteViaPassword(note, noteText, encryptionParams.password);
+  const encryptedContent = await encrypt(encryptionParams);
 
-  encryptedNote.encrypted = true;
-  return [encryptedNote, encryptedNoteText];
-}
-export async function encryptNoteViaPassword<T extends AbstractEncryptedNote>(
-  note: T,
-  noteText: string,
-  password: string
-): Promise<[T, string]> {
-  const encryptedNoteText = await encryptViaPassword(noteText, password);
-  return [
-    {
-      ...note,
-      encrypted: ModelsPublicNoteEncryptionTypeEnum.GpgPassword,
-    },
-    encryptedNoteText,
-  ];
-}
+  const encryptedNote = { ...note, encrypted: true };
 
-export async function encryptNoteViaKeys<T extends AbstractEncryptedNote>(
-  note: T,
-  noteText: string,
-  publicKey: string,
-  privateKey: string,
-  privateKeyPassphrase?: string
-): Promise<[T, string]> {
-  const encryptedNoteText = await encryptViaKeys(
-    noteText,
-    publicKey,
-    privateKey,
-    privateKeyPassphrase
-  );
-
-  return [
-    {
-      ...note,
-      encrypted: ModelsPublicNoteEncryptionTypeEnum.GpgKeys,
-    },
-    encryptedNoteText,
-  ];
+  return [encryptedNote, encryptedContent];
 }
 
 export async function decryptNote<T extends AbstractEncryptedNote>(
   note: T,
-  noteText: string,
-  encryptionParams: OrgNoteEncryption
+  encryptionParams: WithNoteDecryptionContent<OrgNoteEncryption>
 ): EncryptionResult<T> {
-  const isContentEncrypted = isGpgEncrypted(noteText);
+  const isContentEncrypted = isGpgEncrypted(encryptionParams.content);
   if (
     note.meta.published ||
-    !note.encryptionType ||
     !encryptionParams.type ||
     encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.Disabled ||
     !isContentEncrypted
   ) {
     note.encrypted = isContentEncrypted;
-    return [note, noteText];
+    return [note, encryptionParams.content];
   }
   note.encrypted = true;
-  const [decryptedNote, decryptedNoteText] =
-    encryptionParams.type === ModelsPublicNoteEncryptionTypeEnum.GpgKeys
-      ? await decryptNoteViaKeys(
-          note,
-          noteText,
-          encryptionParams.privateKey,
-          encryptionParams.privateKeyPassphrase
-        )
-      : await decryptNoteViaPassword(note, noteText, encryptionParams.password);
+  const decryptionParams = {
+    ...encryptionParams,
+    format: 'utf8',
+  } as WithDecryptionContent<OrgNoteEncryption>;
 
+  const decryptedNoteText = await decrypt(decryptionParams);
   const parsed = withMetaInfo(parse(decryptedNoteText));
 
   return [
     {
-      ...decryptedNote,
+      ...note,
       encrypted: false,
       meta: parsed.meta,
     },
     decryptedNoteText,
   ];
 }
-
-export async function decryptNoteViaPassword<T extends AbstractEncryptedNote>(
-  note: T,
-  noteText: string,
-  password: string
-): EncryptionResult<T> {
-  const decryptedNoteText = await decryptViaPassword(noteText, password);
-  return [
-    {
-      ...note,
-      encrypted: ModelsPublicNoteEncryptionTypeEnum.GpgPassword,
-    },
-    decryptedNoteText,
-  ];
-}
-
-export async function decryptNoteViaKeys<T extends AbstractEncryptedNote>(
-  note: T,
-  noteText: string,
-  privateKey: string,
-  privateKeyPassphrase?: string
-): EncryptionResult<T> {
-  const decryptedNoteText = await decryptViaKeys(
-    noteText,
-    privateKey,
-    privateKeyPassphrase
-  );
-  return [
-    {
-      ...note,
-      encrypted: ModelsPublicNoteEncryptionTypeEnum.GpgKeys,
-    },
-    decryptedNoteText,
-  ];
-}

package/models/encryption.ts

@@ -1,8 +1,20 @@
 import type { ModelsPublicNoteEncryptionTypeEnum } from '../remote-api';
 
+export type EcnryptionFormat = 'binary' | 'armored';
+
+export interface BaseOrgNoteEncryption {
+  format?: 'binary' | 'armored';
+}
+
+export interface BaseOrgNoteDecryption {
+  format?: 'utf8' | 'binary';
+}
+
 export interface OrgNoteGpgEncryption {
   type: typeof ModelsPublicNoteEncryptionTypeEnum.GpgKeys;
+  /* Armored private key */
   privateKey: string;
+  /* Armored public key */
   publicKey: string;
   privateKeyPassphrase?: string;
 }
@@ -20,3 +32,19 @@ export type OrgNoteEncryption =
   | OrgNoteGpgEncryption
   | OrgNotePasswordEncryption
   | OrgNoteDisabledEncryption;
+
+export type EncryptionData = {
+  content: string;
+};
+
+export type WithEncryptionContent<
+  T extends OrgNoteEncryption = OrgNoteEncryption,
+> = T & EncryptionData & BaseOrgNoteEncryption;
+
+export type WithDecryptionContent<
+  T extends OrgNoteEncryption = OrgNoteEncryption,
+> = T & EncryptionData & BaseOrgNoteDecryption;
+
+export type WithNoteDecryptionContent<
+  T extends OrgNoteEncryption = OrgNoteEncryption,
+> = T & EncryptionData;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orgnote-api",
-  "version": "0.14.2",
+  "version": "0.15.1",
   "description": "Official API for creating extensions for OrgNote app",
   "type": "module",
   "main": "./index.ts",

package/tools/is-gpg-encrypted.ts

@@ -1,3 +1,6 @@
-export function isGpgEncrypted(text: string): boolean {
+export function isGpgEncrypted(text: string | Uint8Array): boolean {
+  if (text instanceof Uint8Array) {
+    return true;
+  }
   return text.startsWith('-----BEGIN PGP MESSAGE-----');
 }