@azure/msal-node-extensions 1.0.0-alpha.23 → 1.0.0-alpha.25

package/src/{dpapi-addon/Dpapi.ts → Dpapi.ts}

@@ -8,10 +8,5 @@ export interface DpapiBindings{
     unprotectData(encryptData: Uint8Array, optionalEntropy: Uint8Array, scope: string): Uint8Array
 }
 /* eslint-disable-next-line @typescript-eslint/no-var-requires, no-var, import/no-commonjs */
-export var Dpapi: DpapiBindings = require("bindings")({
-    bindings: "dpapi",
-    userDefinedTries: [
-        ["module_root", "node_modules", "@azure", "msal-node-extensions", "build", "Release",  "bindings"],
-    ]
-});
+export var Dpapi: DpapiBindings = require("../build/Release/dpapi.node");
 export default Dpapi;

package/src/dpapi-addon/dpapi_addon.h

@@ -2,5 +2,6 @@
  * Copyright (c) Microsoft Corporation. All rights reserved.
  * Licensed under the MIT License.
  */
+#include <napi.h>
 
-void ProtectDataCommon(bool protect, Nan::NAN_METHOD_ARGS_TYPE info);
+Napi::Value ProtectDataCommon(bool protect, const Napi::CallbackInfo& info);

package/src/dpapi-addon/dpapi_not_supported.cpp

@@ -3,17 +3,11 @@
  * Licensed under the MIT License.
  */
 
-#include <node.h>
+#include <napi.h>
 
-v8::Local<v8::String> CreateUtf8String(v8::Isolate* isolate, char* strData)
+void 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();
 
-	isolate->ThrowException(v8::Exception::Error(
-		CreateUtf8String(isolate, "Data protection API is not available on macOs or Linux")));
+	throw Napi::Error::New(env, "Data protection API is not available on macOs or Linux");
 }

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/persistence/FilePersistenceWithDataProtection.ts

@@ -6,7 +6,7 @@
 import { IPersistence } from "./IPersistence";
 import { FilePersistence } from "./FilePersistence";
 import { PersistenceError } from "../error/PersistenceError";
-import { Dpapi } from "../dpapi-addon/Dpapi";
+import { Dpapi } from "../Dpapi";
 import { DataProtectionScope } from "./DataProtectionScope";
 import { Logger, LoggerOptions } from "@azure/msal-common";
 import { dirname } from "path";