diff options
Diffstat (limited to 'panto_mcp/oauth.lua')
| -rw-r--r-- | panto_mcp/oauth.lua | 458 |
1 files changed, 458 insertions, 0 deletions
diff --git a/panto_mcp/oauth.lua b/panto_mcp/oauth.lua new file mode 100644 index 0000000..b97c1a7 --- /dev/null +++ b/panto_mcp/oauth.lua @@ -0,0 +1,458 @@ +local ext = require('panto').ext +local json = ext.json +local async = require('panto_mcp.async') +local config = require('panto_mcp.config') +local M = {}; M.__index=M +local function nonempty(v) return type(v)=='string' and v~='' and not v:find('[%z\1-\32\127]') end +-- Credentials, fragments and ambiguous authorities are never accepted. +function M.url(value) + if type(value)~='string' or value:find('[%z\1-\32\127\\#]') then return nil end + local scheme,authority,tail=value:match('^([A-Za-z]+)://([^/?]+)(.*)$') + if not scheme then return nil end + scheme=scheme:lower(); if scheme~='https' and scheme~='http' then return nil end + local host,port + if authority:sub(1,1)=='[' then host,port=authority:match('^(%[[%x:]+%])(:?%d*)$') + else host,port=authority:match('^([A-Za-z0-9.-]+)(:?%d*)$') end + if not host or port==':' then return nil end + if port~='' and (not tonumber(port:sub(2)) or tonumber(port:sub(2))<1 or tonumber(port:sub(2))>65535) then return nil end + host=host:lower() + local literal_loopback=host=='[::1]' + local mapped_loopback=false + if host:sub(1,1)=='[' then + local address=host:sub(2,-2); local left,right=address:match('^(.-)::(.-)$') + local groups={} + for group in (left or address):gmatch('[^:]+') do groups[#groups+1]=tonumber(group,16) end + if left then + local suffix={}; for group in right:gmatch('[^:]+') do suffix[#suffix+1]=tonumber(group,16) end + while #groups+#suffix<8 do groups[#groups+1]=0 end + for _,group in ipairs(suffix) do groups[#groups+1]=group end + end + if #groups==8 then + local zeros=true; for i=1,5 do if groups[i]~=0 then zeros=false end end + literal_loopback=zeros and groups[6]==0 and groups[7]==0 and groups[8]==1 + mapped_loopback=zeros and groups[6]==0xffff and groups[7]>=0x7f00 and groups[7]<=0x7fff + end + end + local a,b,c,d=host:match('^(%d+)%.(%d+)%.(%d+)%.(%d+)$') + if a then + for _,octet in ipairs({a,b,c,d}) do + if (#octet>1 and octet:sub(1,1)=='0') or tonumber(octet)>255 then return nil end + end + literal_loopback=a=='127' + elseif host:match('^[%d.]+$') then return nil end + for octet in host:gmatch('[^.]+') do if octet:match('^0x%x+$') then return nil end end + if scheme=='http' and not literal_loopback then return nil end + if (scheme=='https' and port==':443') or (scheme=='http' and port==':80') then port='' end + local origin=scheme..'://'..host..port + if tail=='/' then tail='' end + return origin..tail,origin,tail:match('^[^?]*'),literal_loopback or mapped_loopback or host=='localhost' or host=='localhost.' or host:match('%.localhost%.?$')~=nil +end +function M.prm_urls(resource) + local _,origin,path=M.url(resource); if not origin then return {} end + local root=origin..'/.well-known/oauth-protected-resource' + return path~='' and {root..path,root} or {root} +end +function M.metadata_urls(issuer) + local _,origin,path=M.url(issuer) + if not origin or issuer:find('?',1,true) then return {} end + path=path:gsub('/$','') + local urls={origin..'/.well-known/oauth-authorization-server'..path,origin..'/.well-known/openid-configuration'..path} + if path~='' then urls[#urls+1]=origin..path..'/.well-known/openid-configuration' end + return urls +end +function M.scopes(value) + local out,seen={},{} + if type(value)=='string' then + local parts={}; for part in value:gmatch('%S+') do parts[#parts+1]=part end; value=parts + end + if type(value)~='table' then return out end + for _,v in ipairs(value) do + local valid=type(v)=='string' and v~='' + if valid then + for i=1,#v do + local byte=v:byte(i) + if byte<33 or byte>126 or byte==34 or byte==92 then valid=false; break end + end + end + if valid and not seen[v] then seen[v]=true; out[#out+1]=v end + end + return out +end +function M.union(a,b) + local out=M.scopes(a); local seen={}; for _,v in ipairs(out) do seen[v]=true end + for _,v in ipairs(M.scopes(b)) do if not seen[v] then seen[v]=true; out[#out+1]=v end end + return out +end +-- Commas inside quoted strings are not challenge separators; quoted-pairs are unescaped. +function M.challenge(header) + if type(header)~='string' or #header>16384 or header:find('[\r\n%z]') then return {} end + local chunks,begin,quoted,escaped={},1,false,false + for i=1,#header do + local c=header:sub(i,i) + if escaped then escaped=false + elseif quoted and c=='\\' then escaped=true + elseif c=='"' then quoted=not quoted + elseif c==',' and not quoted then chunks[#chunks+1]=header:sub(begin,i-1); begin=i+1 end + end + if quoted or escaped then return {} end + chunks[#chunks+1]=header:sub(begin) + local candidates,current={},nil + for _,chunk in ipairs(chunks) do + chunk=chunk:match('^%s*(.-)%s*$') + local scheme,rest=chunk:match('^([%w!#$%%&\'*+.^_`|~-]+)%s+(.+)$') + if scheme and not rest:match('^=') then + current={scheme=scheme:lower()}; candidates[#candidates+1]=current; chunk=rest + elseif chunk:match('^[%w_-]+$') then + current={scheme=chunk:lower()}; candidates[#candidates+1]=current; chunk='' + end + if current and chunk~='' then + local key,value=chunk:match('^([%w!#$%%&\'*+.^_`|~-]+)%s*=%s*(.-)%s*$') + if key then + key=key:lower() + if value:sub(1,1)=='"' and value:sub(-1)=='"' then + value=value:sub(2,-2):gsub('\\(.)','%1') + elseif not value:match('^[%w!#$%%&\'*+.^_`|~-]+$') then current.invalid=true end + if current[key]~=nil then current.invalid=true end + current[key]=value + else current.invalid=true end + end + end + local first + for _,c in ipairs(candidates) do + if c.scheme=='bearer' and not c.invalid then + local safe={resource_metadata=c.resource_metadata,scope=c.scope,error=c.error} + if c.resource_metadata then return safe end + first=first or safe + end + end + return first or {} +end +function M.validate_metadata(metadata,issuer) + if type(metadata)~='table' or metadata.issuer~=issuer then return nil,'OAuth metadata issuer mismatch' end + if not M.url(metadata.authorization_endpoint) or not M.url(metadata.token_endpoint) then return nil,'OAuth metadata has unsafe endpoints' end + local s256=false + for _,method in ipairs(type(metadata.code_challenge_methods_supported)=='table' and metadata.code_challenge_methods_supported or {}) do + if method=='S256' then s256=true end + end + if not s256 then return nil,'OAuth server must advertise PKCE S256' end + if metadata.authorization_response_iss_parameter_supported~=nil and type(metadata.authorization_response_iss_parameter_supported)~='boolean' then + return nil,'Invalid OAuth issuer-response metadata' + end + return true +end +function M.session_name(server,resource,issuer,client_id) + local identity=json.encode({resource=resource,issuer=issuer,client_id=client_id}) + return 'mcp.'..server:sub(1,91)..'.'..require('panto_mcp.hash').sha256(identity):sub(1,32) +end +function M.new(cfg,opts) + opts=opts or {} + local resource,origin,_,loopback=M.url(cfg.url) + local self=setmetatable({cfg=cfg,name=cfg.auth,auth=opts.auth or ext.auth, + state=opts.state or ext.state,request_fn=opts.request_fn or ext.http_request, + timer_factory=opts.timer_factory or async.timer,clock=opts.clock or require('luv').now, + timers={},resource=resource,origin=origin,loopback=loopback},M) + self.key='mcp.oauth.server_'..cfg.name + if not cfg.auth and self.state then + local stored=self.state.get(self.key) + if type(stored)=='table' and stored.version==2 and stored.fingerprint==cfg.fingerprint and stored.resource==resource and self:available() then + self.name=stored.name + self:define(stored) + end + end + return self +end +function M:available() + return type(self.auth)=='table' and type(self.auth.define)=='function' and type(self.auth.status)=='function' + and type(self.auth.login)=='function' and type(self.auth.refresh)=='function' and type(self.auth.complete)=='function' +end +function M:login_error() return 'Authentication required; run /mcp-login '..self.cfg.name end +function M:recovery_error(text) + if self.cfg.auth then return text..'; check configured auth with panto auth login/status' end + local hint=(self.cfg.oauth and self.cfg.oauth.client_id) and 'check the configured OAuth client/issuer' or + ('try /mcp-login '..self.cfg.name..' --reregister to replace a stale DCR client') + return text..'; '..hint +end +function M:usable() + local state=self:auth_status().state + return state=='logged_in' or (state=='pending' and self.login_usable==true) +end +function M:configured_error() + return 'Configured auth session rejected (HTTP 401); check its credentials/type with panto auth login/status' +end +function M:auth_status() + if not self.name or not self:available() then return {state='logged_out'} end + local now=self.clock() + if not self.cached_status or now>=(self.status_at or 0)+1000 then + self.cached_status=self.auth.status(self.name) or {state='logged_out'}; self.status_at=now + end + return self.cached_status +end +function M:status() + if not self:available() then return 'unavailable' end + if not self.cfg.auth and not self.definition then return 'undiscovered' end + local state=self:auth_status().state + if self.login_required and state~='pending' then return 'login_required' end + return state +end +function M:request_auth() + if self.cfg.auth then return self.cfg.auth end + if self.definition and (self.refreshing or (not self.login_required and self:usable())) then return self.name end +end +function M:blocked() + if self.refreshing then return false end + return not self.cfg.auth and self.definition and (self.login_required or not self:usable()) +end +function M:before_request() + if self.refreshing then + local ok,err=self.refreshing:await(); if not ok then return nil,err end + end + if self:blocked() then return nil,self:login_error() end + if not self.definition and self.discovery_error and self.clock()<self.retry_at then return nil,self.discovery_error end + return true +end +function M:url_allowed(url) + local canonical,_,_,loopback=M.url(url) + return canonical and (not loopback or self.loopback) +end +function M:define(stored) + if not self:available() then return nil,'MCP OAuth requires a newer panto with panto.ext.auth' end + if not self.resource then return nil,'MCP OAuth requires HTTPS (or literal loopback HTTP)' end + local configured=self.cfg.oauth + if configured and ((configured.issuer and configured.issuer~=stored.issuer) or + (configured.client_id and (not configured.issuer or configured.client_id~=stored.client_id))) then + return nil,'Configured oauth.issuer does not match the discovered authorization server/client' + end + if not self:url_allowed(stored.issuer) or #M.metadata_urls(stored.issuer)==0 then return nil,'Unsafe OAuth issuer for this resource' end + local ok,err=M.validate_metadata(stored.metadata,stored.issuer); if not ok then return nil,err end + if not self:url_allowed(stored.metadata.authorization_endpoint) or not self:url_allowed(stored.metadata.token_endpoint) then return nil,'Unsafe OAuth endpoint for this resource' end + if not nonempty(stored.client_id) or stored.client_secret~=nil then return nil,'Invalid/public-only OAuth client registration; configure oauth.client_id and oauth.issuer' end + local name=M.session_name(self.cfg.name,self.resource,stored.issuer,stored.client_id) + local spec={type='oauth_pkce',authorization_url=stored.metadata.authorization_endpoint,token_url=stored.metadata.token_endpoint, + client_id=stored.client_id,client_secret=configured and configured.client_secret, + scopes=M.scopes(stored.scopes),resource=self.resource,issuer=stored.issuer, + require_iss=stored.metadata.authorization_response_iss_parameter_supported==true} + if not self.auth.define(name,spec) then return nil,'Cannot define MCP OAuth session (check session name/config collision)' end + if self.name and self.name~=name then + -- Runtime definitions are process-local; a stored old name may need restoring for logout. + if not self.auth.define(self.name,self.spec or spec) then return nil,'Cannot restore the previous OAuth session for logout' end + local ok=self.auth.logout and self.auth.logout(self.name) + if not ok then return nil,'Cannot retire the previous OAuth session' end + end + if self.name~=name then self.cached_status=nil; self.login_usable=nil end + self.name=name; self.definition=stored; self.spec=spec + return true +end +function M:save() + if self.state and self.definition then + local d=self.definition + return self.state.set(self.key,{version=2,name=self.name,fingerprint=self.cfg.fingerprint,resource=self.resource,issuer=d.issuer, + metadata=d.metadata,client_id=d.client_id,scopes=d.scopes}) + end + return true +end +function M:invalidate(reregister) + if self.cfg.auth then return end + if self.definition then + self.previous_issuer=self.definition.issuer; self.requested_scopes=self.spec.scopes + end + if reregister and self.state and self.previous_issuer then + self.state.set('mcp.oauth.registration_'..config.hash(self.previous_issuer),nil) + end + if self.state then self.state.set(self.key,nil) end + self.login_poll=(self.login_poll or 0)+1 + self.definition=nil; self.spec=nil; self.cached_status=nil; self.login_required=nil; self.login_url=nil + self.discovery_error=nil; self.retry_at=nil; self.backoff=nil +end +function M:fetch(url,body) + if self.closed then return nil,'session ended' end + if not self:url_allowed(url) then return nil,'Unsafe OAuth discovery URL for this resource' end + local future=async.future() + local opts={url=url,method=body and 'POST' or 'GET',timeout_ms=10000,max_bytes=1024*1024,headers={Accept='application/json'}} + if body then opts.body=json.encode(body); opts.headers['Content-Type']='application/json' end + local ok,handle=pcall(self.request_fn,opts,function(response) + if self.closed then future:resolve(nil,'session ended'); return end + if not response or response.status<200 or response.status>=300 then future:resolve(nil,'OAuth discovery/registration request failed'); return end + local decoded,value=pcall(json.decode,response.body or '') + if not decoded or type(value)~='table' then future:resolve(nil,'Invalid OAuth metadata JSON'); return end + future:resolve(value) + end) + if not ok or not handle then return nil,'OAuth HTTP request could not start' end + self.requests=self.requests or {}; self.requests[handle]=future + local value,err=future:await(); self.requests[handle]=nil + return value,err +end +function M:discover(challenge) + if self.cfg.auth then return nil,self:configured_error() end + challenge=challenge or {} + if self.definition then return true end + if self.discovering then return self.discovering:await() end + if self.discovery_error and self.clock()<self.retry_at then return nil,self.discovery_error end + if not self:available() then return nil,'MCP OAuth requires a newer panto with panto.ext.auth and HTTP POST support' end + if not self.resource then return nil,'MCP OAuth requires HTTPS (or literal loopback HTTP)' end + local future=async.future(); self.discovering=future + local function work() + local urls=challenge.resource_metadata and {challenge.resource_metadata} or M.prm_urls(self.resource) + local prm,expected_resource + for i,url in ipairs(urls) do + local value=self:fetch(url) + if value then + prm=value; expected_resource=(not challenge.resource_metadata and i==2) and self.origin or self.resource + break + end + end + if not prm then return nil,'Cannot discover OAuth protected-resource metadata' end + if M.url(prm.resource)~=expected_resource then return nil,'OAuth protected-resource metadata resource mismatch' end + local servers=type(prm.authorization_servers)=='table' and prm.authorization_servers or {} + local issuer=servers[1] + local pinned=self.cfg.oauth and self.cfg.oauth.issuer + if pinned then + issuer=nil + for _,candidate in ipairs(servers) do if candidate==pinned then issuer=candidate; break end end + if not issuer then return nil,'Configured oauth.issuer is not advertised by the resource' end + end + if not issuer or #M.metadata_urls(issuer)==0 or not self:url_allowed(issuer) then return nil,'OAuth resource has no safe authorization server' end + local metadata + for _,url in ipairs(M.metadata_urls(issuer)) do + local value=self:fetch(url) + if value then + local valid,why=M.validate_metadata(value,issuer); if not valid then return nil,why end + metadata={issuer=issuer,authorization_endpoint=value.authorization_endpoint,token_endpoint=value.token_endpoint, + code_challenge_methods_supported={'S256'},registration_endpoint=value.registration_endpoint, + authorization_response_iss_parameter_supported=value.authorization_response_iss_parameter_supported} + break + end + end + if not metadata then return nil,'Cannot discover OAuth authorization-server metadata' end + if not self:url_allowed(metadata.authorization_endpoint) or not self:url_allowed(metadata.token_endpoint) then return nil,'Unsafe OAuth endpoint for this resource' end + local registration=self.cfg.oauth + local registration_key='mcp.oauth.registration_'..config.hash(issuer) + if not registration or not registration.client_id then + registration=self.state and self.state.get(registration_key) + if type(registration)=='table' and registration.client_secret~=nil then + return nil,self:recovery_error('Confidential DCR is unsupported') + end + if type(registration)~='table' or registration.issuer~=issuer or not nonempty(registration.client_id) then + if not self:url_allowed(metadata.registration_endpoint) then return nil,'OAuth server needs configured oauth.client_id and oauth.issuer (no safe DCR endpoint)' end + local value,why=self:fetch(metadata.registration_endpoint,{client_name='panto-mcp',application_type='native', + redirect_uris={'http://127.0.0.1/callback'},token_endpoint_auth_method='none', + grant_types={'authorization_code','refresh_token'},response_types={'code'}}) + if not value then return nil,why end + if value.client_secret~=nil or (value.token_endpoint_auth_method~=nil and value.token_endpoint_auth_method~='none') then + return nil,'Confidential DCR is unsupported; configure oauth.client_id, oauth.issuer and optional oauth.client_secret' + end + if not nonempty(value.client_id) then return nil,'Invalid OAuth registration response' end + registration={issuer=issuer,client_id=value.client_id} + if self.state and not self.state.set(registration_key,registration) then return nil,'Cannot persist OAuth registration' end + end + end + local scopes=challenge.scope + if scopes==nil then scopes=prm.scopes_supported end + if scopes==nil then scopes=self.cfg.oauth and self.cfg.oauth.scopes end + if self.previous_issuer==issuer then scopes=M.union(scopes,self.requested_scopes) end + local ok,why=self:define({issuer=issuer,metadata=metadata,client_id=registration.client_id,scopes=M.scopes(scopes)}) + if not ok then return nil,why end + if not self:save() then return nil,'Cannot persist OAuth discovery' end + if self.previous_issuer and self.previous_issuer~=issuer and self.state then + self.state.set('mcp.oauth.registration_'..config.hash(self.previous_issuer),nil) + end + return true + end + local ok,value,err=pcall(work) + if not ok then value=nil; err='OAuth discovery failed' end + if not value then + self.backoff=math.min((self.backoff or 2500)*2,60000); self.retry_at=self.clock()+self.backoff; self.discovery_error=err + else self.backoff=nil; self.discovery_error=nil; self.retry_at=nil end + self.discovering=nil; future:resolve(value,err) + return value,err +end +function M:poll(callback,remaining,active) + if self.closed then return end + local t + t=self.timer_factory(1000,function() + self.timers[t]=nil + if self.closed or (active and not active()) then return end + local status=self:auth_status() + if status.state~='pending' then callback(status); return end + if remaining<=1000 then callback(nil); return end + self:poll(callback,remaining-1000,active) + end) + self.timers[t]=true +end +function M:refresh() + if self.refreshing then return self.refreshing:await() end + local future=async.future(); self.refreshing=future + local ok=self.auth.refresh(self.name) + if not ok then self.refreshing=nil; return nil,self.cfg.auth and self:configured_error() or self:recovery_error(self:login_error()) end + self.cached_status={state='pending'}; self.status_at=self.clock() + self:poll(function(status) + self.refreshing=nil + if status and status.state=='logged_in' and not status.error then future:resolve(true) + else future:resolve(nil,self.cfg.auth and self:configured_error() or self:recovery_error(self:login_error())) end + end,70000) + return future:await() +end +function M:recover(data) + local challenge=data.challenge or {} + if data.http_status==403 then + if challenge.error~='insufficient_scope' then return nil,'Forbidden (HTTP 403); check server permissions' end + if self.cfg.auth then return nil,'Configured auth session needs additional scopes; update its scopes and use panto auth login' end + if not self.definition then return nil,'Insufficient scope (HTTP 403); no OAuth definition is available' end + local scopes=M.union(M.union(self.spec.scopes,self:auth_status().scopes),challenge.scope) + self.definition.scopes=scopes + local ok,err=self:define(self.definition); if not ok then return nil,err end + self:save() + return nil,'Additional permission required; run /mcp-login '..self.cfg.name + end + if not self:available() then + return nil,self.cfg.auth and self:configured_error() or 'MCP OAuth requires a newer panto with panto.ext.auth and HTTP POST support' + end + if data.auth_used then + local ok,err=self:refresh() + if ok or self.cfg.auth then return ok,err end + self:invalidate() + local discovered,why=self:discover(challenge) + self.login_required=not self:usable() or nil + return nil,discovered and err or self:recovery_error(why) + end + local ok,err=self:discover(challenge) + if not ok then return nil,err end + if self:request_auth() then return true end + return nil,self:login_error() +end +function M:login(callback_url,on_success,on_error) + if not self:available() then return nil,self.cfg.auth and 'Configured auth login requires a newer panto and an oauth_pkce session; use panto auth login instead' or 'MCP OAuth requires a newer panto with panto.ext.auth' end + if not self.cfg.auth and not self.definition then return nil,'OAuth discovery is not ready; retry /mcp-login '..self.cfg.name..' after checking /mcp' end + local usable=self:usable() + local result + if callback_url then + if not self.auth.complete(self.name,callback_url) then return nil,'OAuth callback rejected; check the URL/state/issuer and retry' end + elseif self.login_url and self:auth_status().state=='pending' then result={url=self.login_url} + else + result=self.auth.login(self.name) + if not result then + local text='Cannot start OAuth login; check that the configured auth session is oauth_pkce' + return nil,self.cfg.auth and text or self:recovery_error(text) + end + self.login_url=result.url + end + self.login_usable=usable; self.login_required=not usable or nil + self.cached_status={state='pending'}; self.status_at=self.clock() + self.login_poll=(self.login_poll or 0)+1 + local generation=self.login_poll + self:poll(function(status) + self.login_required=nil; self.login_url=nil + if status and status.state=='logged_in' and not status.error then + self.login_usable=nil; on_success() + elseif on_error then + on_error(self:recovery_error('OAuth login failed or timed out')) + end + end,670000,function() return generation==self.login_poll end) + return result and result.url or true +end +function M:close() + self.closed=true + for t in pairs(self.timers) do async.close(t) end; self.timers={} + for handle,future in pairs(self.requests or {}) do handle:cancel(); future:resolve(nil,'session ended') end + if self.refreshing then self.refreshing:resolve(nil,'session ended') end +end +return M |
