Is there a ways to validate inside the getOptions function?

[NicolasEsqui01]

I am getting the following error when I want to get the options depending if it is external o internal

This is the error:

This is my code:

[markstos]

The error says is trying to parse some JSON that's not valid because the JSON contains undefined. Modify your code our the module code to add debugging to dump out that JSON to better understand what's wrong with it.

According to your stack trace, it's happening around 82 in passport.js.

[NicolasEsqui01]

Thank you for responseThank you for response. If I comment the line of if(data[key[0]].indexOf('ext') > -1) { provider = 'external' } it don't throw error

[NicolasEsqui01]

Yes, I have the same error

[cjbarth]

Then you're config is wrong.

[NicolasEsqui01]

It only happens to me when it redirects callbackUrl. When It enters through the get method I go through the same place of getOptions.

Here are my routes
router.get( "/login/sso/:provider", config.passport.authenticate("saml", { failureRedirect: "/", failureFlash: true, }) ); router.post( "/login/sso/callback", config.passport.authenticate("saml", { failureRedirect: "/", failureFlash: true, }), controllers.auth.loginSSO );

Here is my code.

import passport from "passport";
import xml2js from "xml2js";
import fs from "node:fs/promises";
import { MultiSamlStrategy } from "passport-saml";
import path from "node:path";
import { error } from "../utils/index";
import httpStatusCodes from "./httpStatusCodes";

// import { Strategy as GoogleStrategy } from "passport-google-oauth20";

export const getXmlAttributes = async function (xml, fields, keys) {
const convertXMLtoJson = await xml2js.parseStringPromise(xml, {
trim: true,
normalize: true,
});

const attributes =
convertXMLtoJson["samlp:Response"]["saml:Assertion"][0][
"saml:AttributeStatement"
][0]["saml:Attribute"];

const data = attributes.reduce((prev, curr) => {
const {
$: { Name },
} = curr;

if (keys.includes(Name)) {
  const [{ _ }] = curr["saml:AttributeValue"];
  const key = fields[Name];
  const value = _;
  prev[key] = value;
}
return prev;

}, {});

return data;
};

const callbackSamlStrategy = function (config) {
return async function (req, profile, done) {
const parserProfile = await xml2js.parseStringPromise(
profile.getSamlResponseXml(),
{ trim: true, normalize: true }
);
const attribute =
parserProfile["samlp:Response"]["saml:Assertion"][0][
"saml:AttributeStatement"
][0]["saml:Attribute"];

const fields = JSON.parse(config.RESPONSE_FIELDS_SAML);
const keys = Object.keys(fields);

const user = attribute.reduce((prev, curr) => {
  const {
    $: { Name },
  } = curr;

  if (keys.includes(Name)) {
    const [{ _ }] = curr["saml:AttributeValue"];
    const key = fields[Name];
    const value = _;
    prev[key] = value;
  }
  return prev;
}, {});
return done(null, user);

};
};

const getConfigByIdp = function () {
const options = new Map();
return {
set(provider, services) {
options.set(provider, services);
return;
},
get(provider, service) {
const idp = options.get(provider);
return idp[service];
},
hasProviderAndService(provider, service) {
const isExistIdp = options.has(provider);
if (!isExistIdp) return false;
const idp = options.get(provider);
if (!Object.prototype.hasOwnProperty.call(idp, service)) return false;
return true;
},
getValues() {
return options.values();
},
};
};

const getConfigBySp = function (services, cert, entryPoint, ms) {
const keySp = Object.keys(services);
// return services with your respective config
return keySp.reduce((prev, curr) => {
prev[curr] = Object.assign({}, services[curr], {
acceptedClockSkewMs: ms,
cert,
entryPoint,
});

return prev;

}, {});
};

const readSamlfile = async function (path) {
const xmlData = await fs.readFile(path, "utf-8");
const data = await xml2js.parseStringPromise(xmlData, {
trim: true,
normalize: true,
});
return data;
};

const multiSamlConfig = async function (idp, sp, ms) {
const parseIdps = JSON.parse(idp);
const parseSp = JSON.parse(sp);
const keysIdps = Object.keys(parseIdps);
const config = getConfigByIdp();

for (const key of keysIdps) {
const pathIdp = path.join(parseIdps[key]);
const result = await readSamlfile(pathIdp);
const entryPoint =
result["md:EntityDescriptor"]["md:IDPSSODescriptor"][0][
"md:SingleSignOnService"
][0].$.Location;
const idpPublicCert =
result["md:EntityDescriptor"]["md:IDPSSODescriptor"][0][
"md:KeyDescriptor"
][0]["dsig:KeyInfo"][0]["dsig:X509Data"][0]["dsig:X509Certificate"][0];
const services = getConfigBySp(parseSp, idpPublicCert, entryPoint, ms);
config.set(key, services);
}

const samlOption = {
passReqToCallback: true,
getSamlOptions: async function (request, done) {
let provider = request?.params?.provider;
if (Object.prototype.hasOwnProperty.call(request?.body, "SAMLResponse")) {
const samlResponse = Buffer.from(
request?.body?.SAMLResponse,
"base64"
).toString("utf8");

    const field = { userPrincipalName: "userPrincipalName" };
    const key = Object.keys(field);

    const data = await getXmlAttributes(
      samlResponse,
      field,
      key
    );

    if(data[key[0]].indexOf('ext') > -1) {
      provider = 'external'
    }
  }

  const hostname = request?.hostname;

  // to validate if the provider and services exist
  if (!config.hasProviderAndService(provider, hostname))
    return done(
      new error.AppError(
        multiSamlConfig.name,
        httpStatusCodes.NOT_FOUND,
        false,
        "The options for that domain are not found"
      )
    );
  return done(null, config.get(provider, hostname))
},

};

const strategy = new MultiSamlStrategy(
samlOption,
callbackSamlStrategy(config)
);

passport.use(strategy);
};

// const strategyGoogle = function (config) {
// const configuraction = {
// clientID: "",
// clientSecret: "",
// callbackURL: "",
// };

// const callbackGoogleStrategy = function () {
// return function (accessToken, refreshToken, profile, cb) {};
// };

// const google = new GoogleStrategy(configuraction, callbackGoogleStrategy());
// passport.use(google);
// };

const config = process.env;
multiSamlConfig(
config?.PATH_CERT_SSO,
config?.SAML_OPTIONS_SSO,
config?.CLOCKSKEWMS_SAML
).catch(console.error)

passport.serializeUser((user, done) => {
done(null, user);
});

passport.deserializeUser((user, done) => {
done(null, user);
});

export { passport };
``

[NicolasEsqui01]

Then you're config is wrong.

If my config is wrong why I can see the log in window and put the credentials?

[cjbarth]

You have + in your config values. That isn't JSON. Please make your config object a proper JSON file before posting more. What is more, Passport is throwing, not passport-saml, so you're actually not in the right place to be asking this question.

Also, please use code fences and pretty print your code when posting.