issuer.html/js/playground.js

419 lines
14 KiB
JavaScript

(function () {
'use strict';
window.ngOauth3App = angular.module('oauth3Playground', [ 'oauth3.org' ])
//window.ngOauth3App = angular.module('oauth3Playground', [ 'ui.router' ])
/*
ngOauth3App.config(function($stateProvider) {
var helloState = {
name: 'hello',
url: '/hello',
template: '<h3>hello world!</h3>'
}
var aboutState = {
name: 'about',
url: '/about',
template: '<h3>Its the UI-Router hello world app!</h3>'
}
$stateProvider.state(helloState);
$stateProvider.state(aboutState);
});
*/
.controller('PlaygroundCtrl', [ '$timeout', 'azp@oauth3.org', function ($timeout, OAUTH3) {
// NOTE: This OAUTH3 is the same as window.OAUTH3, but with angular's promise injected
// TODO: how to load more than one version of oauth3 on the page (i.e. a vanilla version without angular entaglement)
var vm = this;
vm.framework = 'none';
vm.clientUri = OAUTH3.clientUri(window.location);
vm.conf = { debug: undefined, client_id: vm.clientUri, client_uri: vm.clientUri, provider_uri: vm.clientUri };
vm.providerUri = vm.conf.client_uri;
// map of things being debounced presently
vm.debouncing = {};
vm.defaults = { provider: vm.conf.provider_uri, directives: null };
vm.defaults.scopes = [
{ name: 'oauth3_authn', desc: "Basic secure authentication", checked: true }
//{ name: 'authn@oauth3.org', desc: "Basic secure authentication" }
, { name: 'photos@daplie.com', desc: "Access to photos" }
, { name: 'dns', desc: "DNS records (A/AAAA, TXT, SRV, MX, etc)" }
, { name: '*', desc: "FULL ACCOUNT ACCESS" }
];
vm.form = {};
vm.form.id = 'coolaj86@gmail.com';
vm.form.subject = '';
vm.form.userProvider = '';
vm.form.provider = 'sso.hellabit.com';
vm.form.scopes = '';
vm.locks = {};
vm.validated = {};
vm.responses = {};
//
// Convenience for our app
//
vm.fn = {};
vm.fn._debounce = {};
vm.fn.debounceUi = function () {
if (vm.debouncing.user || vm.debouncing.provider) {
vm.locks['login'] = true;
} else {
vm.locks['login'] = false;
}
};
vm.fn.debounce = function (name, time) {
vm.debouncing[name] = true;
vm.fn.debounceUi();
$timeout.cancel(vm.fn._debounce[name]);
vm.fn._debounce[name] = $timeout(function () {
vm.debouncing[name] = false;
vm.fn.debounceUi();
// do nothing, just use promise
return;
}, time || 250);
return vm.fn._debounce[name];
}
vm.fn.changeUser = function () {
var parts = vm.form.id.split('@');
var user;
var provider;
if (/@/.test(vm.form.id)) {
// The username may have a single @, the provider may not
// user@thing.com@whatever.com -> user@thing.com, whatever.com
provider = parts.pop();
user = parts.join('');
} else {
//vm.form.hasUser = false;
user = '';
provider = parts.join('');
}
vm.form.subject = vm.form.id;
return vm.fn.debounce('provider', 250).then(function () {
var parts = vm.form.provider.split('.');
if (!vm.form.providerIndependent) {
vm.form.provider = provider;
}
vm.form.userProvider = provider;
// Careful: don't use state within a debounce function
// uses vm.form.provider for lookup
if (parts.length >= 2 && parts[parts.length - 1].length >= 2 && parts.every(function (p) {return p.length})) {
return vm.api.discover().then(function () {
console.log('[changeUser] vm.directives:');
console.log(vm.directives);
console.log(provider);
console.log(OAUTH3.uri.normalize(vm.directives.issuer));
if (vm.directives && provider === OAUTH3.uri.normalize(vm.directives.issuer)) {
vm.form.subject = user;
} else {
vm.form.subject = vm.form.id;
}
});
}
});
};
vm.fn.changeProvider = function () {
vm.form.providerIndependent = true;
var parts = vm.form.provider.split('.');
vm.fn.debounce('provider', 250).then(function () {
// Careful: don't use state within a debounce function
if (parts.length >= 2 && parts[parts.length - 1].length >= 2 && parts.every(function (p) {return p.length})) {
return vm.api.discover();
}
});
};
vm.fn.toggleAdvanced = function () {
vm.advanced = !vm.advanced;
vm.form.provider = vm.form.userProvider;
if (!vm.advanced) {
vm.form.providerIndependent = false;
vm.fn.changeUser();
}
};
vm.fn.updateDebug = function () {
if (!vm.conf.debug) {
vm.conf.debug = undefined;
}
};
vm.fn.updateScopes = function () {
var scopes = {};
(vm.scopes && vm.scopes.split(',') || []).forEach(function (name) {
scopes[name] = true;
});
vm.defaults.scopes.forEach(function (scope) {
if (scope.checked) {
scopes[scope.name] = true;
} else {
scopes[scope.name] = false;
}
});
vm.form.scopes = Object.keys(scopes).filter(function (key) {
return scopes[key];
}).map(function (key) {
return key;
}).join(',');
vm.api.urls.implicitGrant();
};
vm.fn.lock = function () {
vm._working = true;
};
vm.fn.unlock = function () {
vm._working = false;
};
vm.fn.clearError = function () {
vm.error = null;
};
vm.fn.clearDirectives = function () {
vm.directives = null;
};
// A place for all the generated urls
vm.urls = {};
//
// Wrap around the OAUTH3 APIs
//
vm.api = {};
vm.api.urls = {};
vm.api.authn = {};
vm.api.jwt = {};
vm.api.urls.credentialMeta = function () {
vm.urls.credentialMeta = OAUTH3.urls.credentialMeta(vm.directives, { email: vm.form.id });
};
vm.api.urls.otp = function () {
vm.urls.otp = OAUTH3.urls.otp(vm.directives, { email: vm.form.id });
};
vm.api.authn.otp = function () {
vm.api.urls.otp();
OAUTH3.authn.otp(vm.directives, { email: vm.form.id }).then(function (resp) {
vm.responses.otp = resp;
vm.form.otpUuid = resp.data.code_id;
console.log('vm.responses.otp: (' + typeof resp + ')');
console.log(vm.responses.otp);
console.log('vm.form.otpUuid:');
console.log(vm.form.otpUuid);
vm.api.urls.resourceOwnerPassword();
});
};
vm.api.authn.credentialMeta = function () {
vm.api.urls.credentialMeta();
OAUTH3.authn.loginMeta(vm.directives, { email: vm.form.id });
};
vm.api.authn._ropOpts = function () {
//var opts = { email: vm.form.id, uuid: vm.form.otpUuid, code: vm.form.otpCode };
return vm.api.authn._ropOpts_ = {
client_id: vm.conf.client_uid || undefined
, client_uri: vm.conf.client_uri || undefined
, grant_type: 'password'
, username: vm.form.id || undefined
, password: vm.form.otpCode || undefined
, totp: vm.form.totpToken || undefined
, otp: vm.form.otpCode || "{{otp-code}}"
, password_type: vm.form.otpCode && 'otp' || undefined
, otp_code: vm.form.otpCode || undefined
, otp_id: vm.form.otpUuid || undefined
, otp_uuid: vm.form.otpUuid || undefined
, user_agent: navigator.userAgent || undefined // "AJ's Macbook" for a specific device?
, jwk: vm.form.rememberDevice && opts.jwk || undefined
//, "public_key": opts.rememberDevice && opts.publicKey || undefined
//, "public_key_type": opts.rememberDevice && opts.publicKeyType || undefined // RSA/ECDSA
//, "jwt": opts.jwt // TODO sign a proof with a previously loaded public_key
, debug: vm.form.debug || undefined
};
};
vm.api.urls.resourceOwnerPassword = function () {
vm.urls.resourceOwnerPassword = OAUTH3.urls.resourceOwnerPassword(vm.directives, vm.api.authn._ropOpts());
};
vm.api.authn.resourceOwnerPassword = function () {
vm.api.urls.resourceOwnerPassword();
OAUTH3.authn.resourceOwnerPassword(vm.directives, vm.api.authn._ropOpts()).then(function (resp) {
vm.responses.resourceOwnerPassword = { status: 0, data: resp };
vm.form.accessToken = vm.accessToken = resp.access_token;
vm.form.refreshToken = vm.refreshToken = resp.refresh_token;
vm.ropSession = resp.token;
});
};
vm.api.jwt.decode = function () {
vm.ropSession = OAUTH3.jwt.decode(vm.form.accessToken || vm.accessToken);
};
vm.api.jwt.decodeRefresh = function () {
vm.ropSession = OAUTH3.jwt.decode(vm.form.refreshToken || vm.refreshToken);
};
vm.api.providerUri = function () {
console.log('[DEBUG] providerUri:', vm.providerUri);
try {
vm.providerUri = OAUTH3.uri.normalize(vm.providerUri);
vm.conf.provider_uri = vm.providerUri;
} catch(e) {
vm.error = e;
}
};
vm.api.clientUri = function () {
console.log('[DEBUG] clientUri:', vm.clientUri);
try {
vm.clientUri = OAUTH3.clientUri({ host: vm.clientUri });
if (vm.clientUri) {
console.log('[DEBUG] clientUri:', vm.clientUri);
vm.conf.client_uri = vm.clientUri;
vm.conf.client_id = vm.clientUri;
}
} catch(e) {
vm.error = e;
}
};
vm.api._discoverCount = 0;
vm.api.urls.implicitGrant = function (provider) {
if (!vm.directives) {
console.log('[DEBUG] skipping implicit grant due to missing directives');
return;
}
var opts = {
client_uri: vm.conf.client_uri
, subject: vm.form.subject || undefined
, debug: vm.conf.debug || undefined
, scope: vm.form.scopes || undefined
};
var implicitGrantObj = OAUTH3.urls.implicitGrant(vm.directives, opts);
vm.implicitGrantUrl = (OAUTH3.url.normalize(provider || vm.form.provider) + '/' + implicitGrantObj.url).replace(implicitGrantObj.state, '{{random}}');
}
vm.api.discover = function () {
vm.directives = null;
vm.validated.provider = '';
vm.api._discoverCount += 1;
var latest = vm.api._discoverCount;
var provider = vm.form.provider; // shouldn't be mutable during this time but...
vm.fn.lock();
vm.discoveryObj = OAUTH3.urls.discover(provider, vm.conf);
vm.directivesUrl = OAUTH3.url.normalize(provider) + '/' + vm.discoveryObj.query._pathname;
vm.discoveryUrl = vm.discoveryObj.method + ' ' + vm.discoveryObj.url;
console.log('about to discover');
return OAUTH3.discover(provider, vm.conf).then(function (dir) {
if (latest !== vm.api._discoverCount) {
console.log('[DEBUG] ignoring stale discover response for', provider);
return;
}
console.log('[DEBUG] directives:');
console.log(dir);
vm.validated.provider = provider;
vm.directives = dir;
vm.api.urls.implicitGrant(provider);
//JSON.stringify(dir, null, 2);
}, function (err) {
vm.form.provider = vm.defaults.provider;
vm.validated.provider = vm.defaults.provider;
vm.directives = vm.defaults.directives;
if (latest !== vm.api._discoverCount) {
console.warn('[DEBUG] ignoring stale discover error for', provider);
console.warn(err);
return;
}
console.log('error on discover');
vm.error = err;
}).then(function () {
vm.fn.unlock();
});
};
vm.api.discoverScopes = function () {
var scopes = vm.form.scopes && vm.form.scopes.split(',') || [];
vm.scopesObj = [];
function nextScope() {
var scopename = scopes.shift();
if (!scopename) {
return;
}
// something like https://example.com/.well-known/oauth3.org/scopes/:scopename.json
var scopeUrlObj = OAUTH3.urls.discoverScope(vm.form.provider, {
client_uri: vm.conf.client_uri
, scope: scopename
, debug: vm.conf.debug || undefined
});
vm.scopeUrl = OAUTH3.url.normalize(provider) + '/' + scopeUrlObj.query._pathname;
// something like the discovery url that loads in an iframe
var discoverScopeObj = OAUTH3.urls.discoverScope(vm.form.provider, {
client_uri: vm.conf.client_uri
, scope: scopename
, debug: vm.conf.debug || undefined
});
vm.discoverScopeUrl = OAUTH3.url.normalize(provider) + '/' + discoverScopeObj.url;
// Go and fetch!
return OAUTH3.discoverScopes(vm.form.provider, {
client_uri: vm.conf.client_uri
, scope: scopename
, debug: vm.conf.debug || undefined
}).then(function (scope) {
var allScopes = {};
vm.scopesObj.push(scope);
vm.defaults.scopes.push(scope);
vm.defaults.scopes = vm.defaults.scopes.filter(function (scope) {
if (allScopes[scope.name]) {
return false;
}
allScopes[scope.name] = true;
return true;
});
}, function (err) {
console.error("Error in discover scope:");
console.error(err);
vm.scopesObj.push({ name: scopename, desc: "Error, not found" });
});
}
return nextScope();
};
vm.api.implicitGrant = function () {
var provider = vm.validated.provider;
var opts = {
client_uri: vm.conf.client_uri
, subject: vm.form.subject || undefined
, debug: vm.conf.debug || undefined
, scope: vm.form.scopes || undefined
};
console.log('[DEBUG] vm.directives');
console.log(vm.directives);
vm.implicitGrantObj = OAUTH3.urls.implicitGrant(vm.directives, opts);
console.log('[DEBUG] vm.implicitGrantObj');
console.log(vm.implicitGrantObj);
vm.implicitGrantUrl = (OAUTH3.url.normalize(provider) + '/' + vm.implicitGrantObj.url);
return OAUTH3.implicitGrant(vm.directives, opts).then(function (session) {
vm.session = session;
});
};
vm.form.provider = vm.defaults.provider;
vm.validated.provider = vm.defaults.provider;
vm.api.discover().then(function () {
vm.defaults.directives = vm.directives;
});
vm.fn.updateScopes();
} ] );
}());