@azure/msal-node-extensions 1.0.0-alpha.3 → 1.0.0-alpha.31

package/src/dpapi-addon/dpapi_win.cpp

@@ -4,63 +4,58 @@
  */
  // Implementation referenced from https://github.com/bradhugh/node-dpapi
 
-#include <node.h>
-#include <nan.h>
+#include <napi.h>
+#include <uv.h>
 #include <Windows.h>
 #include <dpapi.h>
 #include <functional>
 #include <iostream>
 #include <string>
 
-v8::Local<v8::String> CreateUtf8String(v8::Isolate* isolate, char* strData)
+Napi::Value ProtectDataCommon(bool protect, const Napi::CallbackInfo& info)
 {
-	return v8::String::NewFromUtf8(isolate, strData, v8::NewStringType::kNormal).ToLocalChecked();
-}
-
-void ProtectDataCommon(bool protect, Nan::NAN_METHOD_ARGS_TYPE info)
-{
-	v8::Isolate* isolate = info.GetIsolate();
+	Napi::Env env = info.Env();
 
 	if (info.Length() != 3) {
-		isolate->ThrowException(v8::Exception::RangeError(
-			CreateUtf8String(isolate, "3 arguments are required")));
+		throw Napi::RangeError::New(env, "3 arguments are required");
 	}
 
-	if (info[0]->IsNullOrUndefined() || !info[0]->IsUint8Array())
+	if (info[0].IsNull() || 
+		info[0].IsUndefined() || 
+		!info[0].IsTypedArray() || 
+		info[0].As<Napi::TypedArray>().TypedArrayType() != napi_uint8_array)
 	{
-		isolate->ThrowException(v8::Exception::TypeError(
-			CreateUtf8String(isolate, "First argument, data, must be a valid Uint8Array")));
+		throw Napi::TypeError::New(env, "First argument, data, must be a valid Uint8Array");
 	}
 
-	if (!info[1]->IsNull() && !info[1]->IsUint8Array())
+	if (!info[1].IsNull() && 
+		(!info[1].IsTypedArray() || info[1].As<Napi::TypedArray>().TypedArrayType() != napi_uint8_array))
 	{
-		isolate->ThrowException(v8::Exception::TypeError(
-			CreateUtf8String(isolate, "Second argument, optionalEntropy, must be null or an ArrayBuffer")));
+		throw Napi::TypeError::New(env, "Second argument, optionalEntropy, must be null or an ArrayBuffer");
 	}
 
-	if (info[2]->IsNullOrUndefined() || !info[2]->IsString())
+	if (info[2].IsNull() || info[2].IsUndefined() || !info[2].IsString())
 	{
-		isolate->ThrowException(v8::Exception::TypeError(
-			CreateUtf8String(isolate, "Third argument, scope, must be a string")));
+		throw Napi::TypeError::New(env, "Third argument, scope, must be a string");
 	}
 
 	DWORD flags = 0;
-	v8::String::Utf8Value strData(isolate, info[2]);
-	std::string scope(*strData);
+	Napi::String strData = info[2].As<Napi::String>();
+	std::string scope = strData.Utf8Value();
 	if (stricmp(scope.c_str(), "LocalMachine") == 0)
 	{
 		flags = CRYPTPROTECT_LOCAL_MACHINE;
 	}
 
-	auto buffer = node::Buffer::Data(info[0]);
-	auto len = node::Buffer::Length(info[0]);
+	auto buffer = info[0].As<Napi::Buffer<char>>().Data();
+	auto len = info[0].As<Napi::Buffer<char>>().ElementLength();
 
 	DATA_BLOB entropyBlob;
 	entropyBlob.pbData = nullptr;
-	if (!info[1]->IsNull())
+	if (!info[1].IsNull())
 	{
-		entropyBlob.pbData = reinterpret_cast<BYTE*>(node::Buffer::Data(info[1]));
-		entropyBlob.cbData = node::Buffer::Length(info[1]);
+		entropyBlob.pbData = reinterpret_cast<BYTE*>(info[1].As<Napi::Buffer<char>>().Data());
+		entropyBlob.cbData = info[1].As<Napi::Buffer<char>>().ElementLength();
 	}
 
 	DATA_BLOB dataIn;
@@ -100,15 +95,12 @@ void ProtectDataCommon(bool protect, Nan::NAN_METHOD_ARGS_TYPE info)
 	{
 		DWORD errorCode = GetLastError();
 		std::string errorMessage = std::string("Encryption/Decryption failed. Error code: ") + std::to_string(errorCode);
-		isolate->ThrowException(v8::Exception::Error(
-			CreateUtf8String(isolate, &errorMessage[0])));
-
-		return;
+		throw Napi::Error::New(env, &errorMessage[0]);
 	}
 
 	// Copy and free the buffer
-	auto returnBuffer = Nan::CopyBuffer(reinterpret_cast<const char*>(dataOut.pbData), dataOut.cbData).ToLocalChecked();
+	Napi::Buffer<char> returnBuffer = Napi::Buffer<char>::Copy(env, reinterpret_cast<char*>(dataOut.pbData), dataOut.cbData);
 	LocalFree(dataOut.pbData);
 
-	info.GetReturnValue().Set(returnBuffer);
+	return returnBuffer;
 }

package/src/dpapi-addon/main.cpp

@@ -3,30 +3,28 @@
  * Licensed under the MIT License.
  */
 
-#include <nan.h>
+#include <napi.h>
+#include <uv.h>
 #include "dpapi_addon.h"
 
-NAN_METHOD(protectData)
+Napi::Value protectData(const Napi::CallbackInfo& info)
 {
-	ProtectDataCommon(true, info);
+	return ProtectDataCommon(true, info);
 }
 
-NAN_METHOD(unprotectData)
+Napi::Value unprotectData(const Napi::CallbackInfo& info)
 {
-	ProtectDataCommon(false, info);
+	return ProtectDataCommon(false, info);
 }
 
-NAN_MODULE_INIT(init)
-{
-	Nan::Set(
-		target,
-		Nan::New<v8::String>("protectData").ToLocalChecked(),
-		Nan::GetFunction(Nan::New<v8::FunctionTemplate>(protectData)).ToLocalChecked());
+Napi::Object init(Napi::Env env, Napi::Object exports) {
+	exports.Set(Napi::String::New(env, "protectData"),
+		Napi::Function::New(env, protectData));
 
-	Nan::Set(
-		target,
-		Nan::New<v8::String>("unprotectData").ToLocalChecked(),
-		Nan::GetFunction(Nan::New<v8::FunctionTemplate>(unprotectData)).ToLocalChecked());
+	exports.Set(Napi::String::New(env, "unprotectData"),
+		Napi::Function::New(env, unprotectData));
+	
+	return exports;
 }
 
-NODE_MODULE(binding, init)
+NODE_API_MODULE(dpapi, init)

package/src/error/NativeAuthError.ts

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { AuthError } from "@azure/msal-common";
+
+export class NativeAuthError extends AuthError {
+    public statusCode: number;
+    public tag: number;
+
+    constructor(errorStatus: string, errorContext: string, errorCode: number, errorTag: number) {
+        super(errorStatus, errorContext);
+        this.name = "NativeAuthError";
+        this.statusCode = errorCode;
+        this.tag = errorTag;
+        Object.setPrototypeOf(this, NativeAuthError.prototype);
+    }
+}

package/src/error/PersistenceError.ts

@@ -1,61 +1,101 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-/**
- * Error thrown when trying to write MSAL cache to persistence.
- */
-export class PersistenceError extends Error {
-
-    // Short string denoting error
-    errorCode: string;
-    // Detailed description of error
-    errorMessage: string;
-
-    constructor(errorCode: string, errorMessage: string) {
-        const errorString = errorMessage ? `${errorCode}: ${errorMessage}` : errorCode;
-        super(errorString);
-        Object.setPrototypeOf(this, PersistenceError.prototype);
-
-        this.errorCode = errorCode;
-        this.errorMessage = errorMessage;
-        this.name = "PersistenceError";
-    }
-
-    /**
-     * Error thrown when trying to access the file system.
-     */
-    static createFileSystemError(errorCode: string, errorMessage: string): PersistenceError {
-        return new PersistenceError(errorCode, errorMessage);
-    }
-
-    /**
-     * Error thrown when trying to write, load, or delete data from secret service on linux.
-     * Libsecret is used to access secret service.
-     */
-    static createLibSecretError(errorMessage: string): PersistenceError {
-        return new PersistenceError("GnomeKeyringError", errorMessage);
-    }
-
-    /**
-     * Error thrown when trying to write, load, or delete data from keychain on macOs.
-     */
-    static createKeychainPersistenceError(errorMessage: string): PersistenceError {
-        return new PersistenceError("KeychainError", errorMessage);
-    }
-
-    /**
-     * Error thrown when trying to encrypt or decrypt data using DPAPI on Windows.
-     */
-    static createFilePersistenceWithDPAPIError(errorMessage: string): PersistenceError {
-        return new PersistenceError("DPAPIEncryptedFileError", errorMessage);
-    }
-
-    /**
-     * Error thrown when using the cross platform lock.
-     */
-    static createCrossPlatformLockError(errorMessage: string): PersistenceError {
-        return new PersistenceError("CrossPlatformLockError", errorMessage);
-    }
-}
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * Error thrown when trying to write MSAL cache to persistence.
+ */
+export class PersistenceError extends Error {
+
+    // Short string denoting error
+    errorCode: string;
+    // Detailed description of error
+    errorMessage: string;
+
+    constructor(errorCode: string, errorMessage: string) {
+        const errorString = errorMessage ? `${errorCode}: ${errorMessage}` : errorCode;
+        super(errorString);
+        Object.setPrototypeOf(this, PersistenceError.prototype);
+
+        this.errorCode = errorCode;
+        this.errorMessage = errorMessage;
+        this.name = "PersistenceError";
+    }
+
+    /**
+     * Error thrown when trying to access the file system.
+     */
+    static createFileSystemError(errorCode: string, errorMessage: string): PersistenceError {
+        return new PersistenceError(errorCode, errorMessage);
+    }
+
+    /**
+     * Error thrown when trying to write, load, or delete data from secret service on linux.
+     * Libsecret is used to access secret service.
+     */
+    static createLibSecretError(errorMessage: string): PersistenceError {
+        return new PersistenceError("GnomeKeyringError", errorMessage);
+    }
+
+    /**
+     * Error thrown when trying to write, load, or delete data from keychain on macOs.
+     */
+    static createKeychainPersistenceError(errorMessage: string): PersistenceError {
+        return new PersistenceError("KeychainError", errorMessage);
+    }
+
+    /**
+     * Error thrown when trying to encrypt or decrypt data using DPAPI on Windows.
+     */
+    static createFilePersistenceWithDPAPIError(errorMessage: string): PersistenceError {
+        return new PersistenceError("DPAPIEncryptedFileError", errorMessage);
+    }
+
+    /**
+     * Error thrown when using the cross platform lock.
+     */
+    static createCrossPlatformLockError(errorMessage: string): PersistenceError {
+        return new PersistenceError("CrossPlatformLockError", errorMessage);
+    }
+
+    /**
+     * Throw cache persistence error
+     * 
+     * @param errorMessage string
+     * @returns PersistenceError
+     */
+    static createCachePersistenceError(errorMessage: string): PersistenceError {
+        return new PersistenceError("CachePersistenceError", errorMessage);
+    }
+
+    /**
+     * Throw unsupported error
+     * 
+     * @param errorMessage string
+     * @returns PersistenceError
+     */
+    static createNotSupportedError(errorMessage: string): PersistenceError {
+        return new PersistenceError("NotSupportedError", errorMessage);
+    }
+
+    /**
+     * Throw persistence not verified error
+     * 
+     * @param errorMessage string
+     * @returns PersistenceError
+     */
+    static createPersistenceNotVerifiedError(errorMessage: string): PersistenceError {
+        return new PersistenceError("PersistenceNotVerifiedError", errorMessage);
+    }
+
+    /**
+     * Throw persistence creation validation error
+     * 
+     * @param errorMessage string
+     * @returns PersistenceError
+     */
+    static createPersistenceNotValidatedError(errorMessage: string): PersistenceError {
+        return new PersistenceError("PersistenceNotValidatedError", errorMessage);
+    }
+}

package/src/index.ts

@@ -1,8 +1,17 @@
-export { PersistenceCachePlugin } from "./persistence/PersistenceCachePlugin";
-export { FilePersistence } from "./persistence/FilePersistence";
-export { FilePersistenceWithDataProtection } from "./persistence/FilePersistenceWithDataProtection";
-export { DataProtectionScope } from "./persistence/DataProtectionScope";
-export { KeychainPersistence } from "./persistence/KeychainPersistence";
-export { LibSecretPersistence } from "./persistence/LibSecretPersistence";
-export { IPersistence } from "./persistence/IPersistence";
-export { CrossPlatformLockOptions } from "./lock/CrossPlatformLockOptions";
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export { PersistenceCachePlugin } from "./persistence/PersistenceCachePlugin";
+export { FilePersistence } from "./persistence/FilePersistence";
+export { FilePersistenceWithDataProtection } from "./persistence/FilePersistenceWithDataProtection";
+export { DataProtectionScope } from "./persistence/DataProtectionScope";
+export { KeychainPersistence } from "./persistence/KeychainPersistence";
+export { LibSecretPersistence } from "./persistence/LibSecretPersistence";
+export { IPersistence } from "./persistence/IPersistence";
+export { CrossPlatformLockOptions } from "./lock/CrossPlatformLockOptions";
+export { PersistenceCreator } from "./persistence/PersistenceCreator";
+export { IPersistenceConfiguration } from "./persistence/IPersistenceConfiguration";
+export { Environment } from "./utils/Environment";
+export { NativeBrokerPlugin } from "./broker/NativeBrokerPlugin";

package/src/lock/CrossPlatformLock.ts

@@ -1,89 +1,89 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { promises as fs } from "fs";
-import { pid } from "process";
-import { CrossPlatformLockOptions } from "./CrossPlatformLockOptions";
-import { Constants } from "../utils/Constants";
-import { PersistenceError } from "../error/PersistenceError";
-import { Logger } from "@azure/msal-common";
-
-/**
- * Cross-process lock that works on all platforms.
- */
-export class CrossPlatformLock {
-
-    private readonly lockFilePath: string;
-    private lockFileHandle: fs.FileHandle;
-    private readonly retryNumber: number;
-    private readonly retryDelay: number;
-
-    private logger: Logger;
-
-    constructor(lockFilePath: string, logger: Logger, lockOptions?: CrossPlatformLockOptions) {
-        this.lockFilePath = lockFilePath;
-        this.retryNumber = lockOptions ? lockOptions.retryNumber : 500;
-        this.retryDelay = lockOptions ? lockOptions.retryDelay : 100;
-        this.logger = logger;
-    }
-
-    /**
-     * Locks cache from read or writes by creating file with same path and name as
-     * cache file but with .lockfile extension. If another process has already created
-     * the lockfile, will back off and retry based on configuration settings set by CrossPlatformLockOptions
-     */
-    public async lock(): Promise<void> {
-        for (let tryCount = 0; tryCount < this.retryNumber; tryCount++) {
-            try {
-                this.logger.info(`Pid ${pid} trying to acquire lock`);
-                this.lockFileHandle = await fs.open(this.lockFilePath, "wx+");
-
-                this.logger.info(`Pid ${pid} acquired lock`);
-                await this.lockFileHandle.write(pid.toString());
-                return;
-            } catch (err) {
-                if (err.code == Constants.EEXIST_ERROR || err.code == Constants.EPERM_ERROR) {
-                    this.logger.info(err);
-                    await this.sleep(this.retryDelay);
-                } else {
-                    this.logger.error(`${pid} was not able to acquire lock. Ran into error: ${err.message}`);
-                    throw PersistenceError.createCrossPlatformLockError(err.message);
-                }
-            }
-        }
-        this.logger.error(`${pid} was not able to acquire lock. Exceeded amount of retries set in the options`);
-        throw PersistenceError.createCrossPlatformLockError(
-            "Not able to acquire lock. Exceeded amount of retries set in options");
-    }
-
-    /**
-     * unlocks cache file by deleting .lockfile.
-     */
-    public async unlock(): Promise<void> {
-        try {
-            if(this.lockFileHandle){
-                // if we have a file handle to the .lockfile, delete lock file
-                await fs.unlink(this.lockFilePath);
-                await this.lockFileHandle.close();
-                this.logger.info("lockfile deleted");
-            } else {
-                this.logger.warning("lockfile handle does not exist, so lockfile could not be deleted");
-            }
-        } catch (err) {
-            if (err.code == Constants.ENOENT_ERROR) {
-                this.logger.warning("Tried to unlock but lockfile does not exist");
-            } else {
-                this.logger.error(`${pid} was not able to release lock. Ran into error: ${err.message}`);
-                throw PersistenceError.createCrossPlatformLockError(err.message);
-            }
-        }
-    }
-
-    private sleep(ms): Promise<void> {
-        return new Promise((resolve) => {
-            setTimeout(resolve, ms);
-        });
-    }
-}
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { promises as fs } from "fs";
+import { pid } from "process";
+import { CrossPlatformLockOptions } from "./CrossPlatformLockOptions";
+import { Constants } from "../utils/Constants";
+import { PersistenceError } from "../error/PersistenceError";
+import { Logger } from "@azure/msal-common";
+
+/**
+ * Cross-process lock that works on all platforms.
+ */
+export class CrossPlatformLock {
+
+    private readonly lockFilePath: string;
+    private lockFileHandle: fs.FileHandle;
+    private readonly retryNumber: number;
+    private readonly retryDelay: number;
+
+    private logger: Logger;
+
+    constructor(lockFilePath: string, logger: Logger, lockOptions?: CrossPlatformLockOptions) {
+        this.lockFilePath = lockFilePath;
+        this.retryNumber = lockOptions ? lockOptions.retryNumber : 500;
+        this.retryDelay = lockOptions ? lockOptions.retryDelay : 100;
+        this.logger = logger;
+    }
+
+    /**
+     * Locks cache from read or writes by creating file with same path and name as
+     * cache file but with .lockfile extension. If another process has already created
+     * the lockfile, will back off and retry based on configuration settings set by CrossPlatformLockOptions
+     */
+    public async lock(): Promise<void> {
+        for (let tryCount = 0; tryCount < this.retryNumber; tryCount++) {
+            try {
+                this.logger.info(`Pid ${pid} trying to acquire lock`);
+                this.lockFileHandle = await fs.open(this.lockFilePath, "wx+");
+
+                this.logger.info(`Pid ${pid} acquired lock`);
+                await this.lockFileHandle.write(pid.toString());
+                return;
+            } catch (err) {
+                if (err.code === Constants.EEXIST_ERROR || err.code === Constants.EPERM_ERROR) {
+                    this.logger.info(err);
+                    await this.sleep(this.retryDelay);
+                } else {
+                    this.logger.error(`${pid} was not able to acquire lock. Ran into error: ${err.message}`);
+                    throw PersistenceError.createCrossPlatformLockError(err.message);
+                }
+            }
+        }
+        this.logger.error(`${pid} was not able to acquire lock. Exceeded amount of retries set in the options`);
+        throw PersistenceError.createCrossPlatformLockError(
+            "Not able to acquire lock. Exceeded amount of retries set in options");
+    }
+
+    /**
+     * unlocks cache file by deleting .lockfile.
+     */
+    public async unlock(): Promise<void> {
+        try {
+            if(this.lockFileHandle){
+                // if we have a file handle to the .lockfile, delete lock file
+                await fs.unlink(this.lockFilePath);
+                await this.lockFileHandle.close();
+                this.logger.info("lockfile deleted");
+            } else {
+                this.logger.warning("lockfile handle does not exist, so lockfile could not be deleted");
+            }
+        } catch (err) {
+            if (err.code === Constants.ENOENT_ERROR) {
+                this.logger.info("Tried to unlock but lockfile does not exist");
+            } else {
+                this.logger.error(`${pid} was not able to release lock. Ran into error: ${err.message}`);
+                throw PersistenceError.createCrossPlatformLockError(err.message);
+            }
+        }
+    }
+
+    private sleep(ms): Promise<void> {
+        return new Promise((resolve) => {
+            setTimeout(resolve, ms);
+        });
+    }
+}

package/src/lock/CrossPlatformLockOptions.ts

@@ -1,15 +1,15 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-/**
- * Options for CrossPlatform lock.
- *
- * retryNumber: Numbers of times we should try to acquire a lock. Defaults to 500.
- * retryDelay: Time to wait before trying to retry a lock acquisition. Defaults to 100 ms.
- */
-export type CrossPlatformLockOptions = {
-    retryNumber: number;
-    retryDelay: number;
-};
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * Options for CrossPlatform lock.
+ *
+ * retryNumber: Numbers of times we should try to acquire a lock. Defaults to 500.
+ * retryDelay: Time to wait before trying to retry a lock acquisition. Defaults to 100 ms.
+ */
+export type CrossPlatformLockOptions = {
+    retryNumber: number;
+    retryDelay: number;
+};

package/src/packageMetadata.ts

@@ -0,0 +1,3 @@
+/* eslint-disable header/header */
+export const name = "@azure/msal-node-extensions";
+export const version = "1.0.0-alpha.31";

package/src/persistence/BasePersistence.ts

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { PersistenceError } from "../error/PersistenceError";
+import { Constants } from "../utils/Constants";
+import { IPersistence } from "./IPersistence";
+
+export abstract class BasePersistence {
+    public abstract createForPersistenceValidation(): Promise<IPersistence>; 
+
+    public async verifyPersistence(): Promise<boolean> {
+        // We are using a different location for the test to avoid overriding the functional cache
+        const persistenceValidator = await this.createForPersistenceValidation();
+
+        try {
+            await persistenceValidator.save(Constants.PERSISTENCE_TEST_DATA);
+
+            const retrievedDummyData = await persistenceValidator.load();
+
+            if (!retrievedDummyData) {
+                throw PersistenceError.createCachePersistenceError(
+                    "Persistence check failed. Data was written but it could not be read. " +
+                    "Possible cause: on Linux, LibSecret is installed but D-Bus isn't running \
+                    because it cannot be started over SSH."
+                );
+            }
+
+            if (retrievedDummyData !== Constants.PERSISTENCE_TEST_DATA) {
+                throw PersistenceError.createCachePersistenceError(
+                    `Persistence check failed. Data written ${Constants.PERSISTENCE_TEST_DATA} is different \
+                    from data read ${retrievedDummyData}`
+                );
+            }
+            await persistenceValidator.delete();
+            return true;
+        } catch (e) {
+            throw PersistenceError.createCachePersistenceError(`Verifing persistence failed with the error: ${e}`);
+        }
+    }
+
+}