定位:身份层(IdP + IAP),不含动态域名转发 / LLM 上游代理 / 用量计费。 代码(source/rust,nginx 动态模块 + Rust,单进程零外部依赖) - IdP:authorization_code(含 PKCE)/ refresh_token / client_credentials / password 四种 grant,含 discovery / introspect / userinfo / jwks 占位 - IAP:access 阶段门禁,注入 X-Auth-* 到后端,客户端伪造同名头被覆盖 - MaxKey 互通:/oauth/v20/* 与 /oauth2.0/* 别名 + context-path 归一化 + 扁平字段 - 管理接口:账号(含角色/部门/用户组)与 OAuth 接入方注册表,热写穿共享内存 - 模块改名 ngx_http_sso_module,指令 sso_state / sso_data_dir / sso_api / sso_iap, Cookie sso_sid(终端用户)与 sso_admin_session(管理员)两套身份两套会话 配置(source/conf) - nginx.conf 生产模板(TLS、IAP 子域、含 auth_sub 的日志格式) - nginx.test.conf 本机验证配置(明文 18095-18099) - tls/README.md 证书约定与公钥比对校验 前端(source/www/admin.html) - 三 tab:账号管理 / 接入方 / 接入指南;去掉审核队列、域名、LLM 上游、用量统计 测试与脚本 - tests/ 三套端到端:协议基线 14 项 · MaxKey 互通与接入 24 项 · 管理接口 31 项,全绿 - tests/demo-system 演示业务系统(Python 标准库),覆盖应用自建客户端与 IAP 零改造两种姿势 - scripts/run-local-e2e.sh 本机一键起停;scripts/seed-data.sh 物化运行时数据目录 文档 - README.md 概览与快速开始;CLAUDE.md 硬约定与排障速查 - docs/design.md 完整设计;docs/roadmap.md 待执行任务(v2 RS256+JWKS、用户管理界面)
426 lines
13 KiB
Rust
426 lines
13 KiB
Rust
#![no_std]
|
|
use core::ffi::{c_char, c_void};
|
|
use core::mem;
|
|
use core::ptr::{self, NonNull};
|
|
|
|
use nginx_sys::{
|
|
NGX_CONF_TAKE2, NGX_HTTP_DELETE, NGX_HTTP_MAIN_CONF, NGX_HTTP_MAIN_CONF_OFFSET,
|
|
NGX_HTTP_MODULE, NGX_HTTP_VAR_CHANGEABLE, NGX_HTTP_VAR_NOCACHEABLE, NGX_LOG_EMERG,
|
|
ngx_command_t, ngx_conf_t, ngx_http_add_variable, ngx_http_compile_complex_value_t,
|
|
ngx_http_complex_value, ngx_http_complex_value_t, ngx_http_module_t, ngx_http_request_t,
|
|
ngx_http_variable_t, ngx_http_variable_value_t, ngx_int_t, ngx_module_t, ngx_parse_size,
|
|
ngx_shared_memory_add, ngx_shm_zone_t, ngx_str_t, ngx_uint_t,
|
|
};
|
|
use ngx::collections::RbTreeMap;
|
|
use ngx::core::{NGX_CONF_ERROR, NGX_CONF_OK, NgxStr, NgxString, Pool, SlabPool, Status};
|
|
use ngx::http::{HttpModule, HttpModuleMainConf};
|
|
use ngx::{ngx_conf_log_error, ngx_log_debug, ngx_string};
|
|
|
|
struct HttpSharedDictModule;
|
|
|
|
impl HttpModule for HttpSharedDictModule {
|
|
fn module() -> &'static ngx_module_t {
|
|
unsafe { &*ptr::addr_of!(ngx_http_shared_dict_module) }
|
|
}
|
|
|
|
unsafe extern "C" fn preconfiguration(cf: *mut ngx_conf_t) -> ngx_int_t {
|
|
for mut v in unsafe { NGX_HTTP_SHARED_DICT_VARS } {
|
|
let var = NonNull::new(unsafe { ngx_http_add_variable(cf, &raw mut v.name, v.flags) });
|
|
if var.is_none() {
|
|
return Status::NGX_ERROR.into();
|
|
}
|
|
let var = unsafe { var.unwrap().as_mut() };
|
|
var.get_handler = v.get_handler;
|
|
var.set_handler = v.set_handler;
|
|
var.data = v.data;
|
|
}
|
|
Status::NGX_OK.into()
|
|
}
|
|
}
|
|
|
|
unsafe impl HttpModuleMainConf for HttpSharedDictModule {
|
|
type MainConf = SharedDictMainConfig;
|
|
}
|
|
|
|
static mut NGX_HTTP_SHARED_DICT_COMMANDS: [ngx_command_t; 3] = [
|
|
ngx_command_t {
|
|
name: ngx_string!("shared_dict_zone"),
|
|
type_: (NGX_HTTP_MAIN_CONF | NGX_CONF_TAKE2) as ngx_uint_t,
|
|
set: Some(ngx_http_shared_dict_add_zone),
|
|
conf: NGX_HTTP_MAIN_CONF_OFFSET,
|
|
offset: 0,
|
|
post: ptr::null_mut(),
|
|
},
|
|
ngx_command_t {
|
|
name: ngx_string!("shared_dict"),
|
|
type_: (NGX_HTTP_MAIN_CONF | NGX_CONF_TAKE2) as ngx_uint_t,
|
|
set: Some(ngx_http_shared_dict_add_variable),
|
|
conf: NGX_HTTP_MAIN_CONF_OFFSET,
|
|
offset: 0,
|
|
post: ptr::null_mut(),
|
|
},
|
|
ngx_command_t::empty(),
|
|
];
|
|
|
|
static mut NGX_HTTP_SHARED_DICT_VARS: [ngx_http_variable_t; 1] = [ngx_http_variable_t {
|
|
name: ngx_string!("shared_dict_entries"),
|
|
set_handler: Some(ngx_http_shared_dict_set_entries),
|
|
get_handler: Some(ngx_http_shared_dict_get_entries),
|
|
data: 0,
|
|
flags: (NGX_HTTP_VAR_CHANGEABLE | NGX_HTTP_VAR_NOCACHEABLE) as ngx_uint_t,
|
|
index: 0,
|
|
}];
|
|
|
|
static NGX_HTTP_SHARED_DICT_MODULE_CTX: ngx_http_module_t = ngx_http_module_t {
|
|
preconfiguration: Some(HttpSharedDictModule::preconfiguration),
|
|
postconfiguration: None,
|
|
create_main_conf: Some(HttpSharedDictModule::create_main_conf),
|
|
init_main_conf: None,
|
|
create_srv_conf: None,
|
|
merge_srv_conf: None,
|
|
create_loc_conf: None,
|
|
merge_loc_conf: None,
|
|
};
|
|
|
|
// Generate the `ngx_modules` table with exported modules.
|
|
// This feature is required to build a 'cdylib' dynamic module outside of the NGINX buildsystem.
|
|
#[cfg(feature = "export-modules")]
|
|
ngx::ngx_modules!(ngx_http_shared_dict_module);
|
|
|
|
#[used]
|
|
#[allow(non_upper_case_globals)]
|
|
#[cfg_attr(not(feature = "export-modules"), unsafe(no_mangle))]
|
|
pub static mut ngx_http_shared_dict_module: ngx_module_t = ngx_module_t {
|
|
ctx: &raw const NGX_HTTP_SHARED_DICT_MODULE_CTX as _,
|
|
commands: unsafe { &raw mut NGX_HTTP_SHARED_DICT_COMMANDS[0] },
|
|
type_: NGX_HTTP_MODULE as _,
|
|
..ngx_module_t::default()
|
|
};
|
|
|
|
type SharedData = ngx::sync::RwLock<RbTreeMap<NgxString<SlabPool>, NgxString<SlabPool>, SlabPool>>;
|
|
|
|
#[derive(Debug)]
|
|
struct SharedDictMainConfig {
|
|
shm_zone: *mut ngx_shm_zone_t,
|
|
}
|
|
|
|
impl Default for SharedDictMainConfig {
|
|
fn default() -> Self {
|
|
Self { shm_zone: ptr::null_mut() }
|
|
}
|
|
}
|
|
|
|
extern "C" fn ngx_http_shared_dict_add_zone(
|
|
cf: *mut ngx_conf_t,
|
|
_cmd: *mut ngx_command_t,
|
|
conf: *mut c_void,
|
|
) -> *mut c_char {
|
|
// SAFETY: configuration handlers always receive a valid `cf` pointer.
|
|
let cf = unsafe { cf.as_mut().unwrap() };
|
|
let smcf =
|
|
unsafe { conf.cast::<SharedDictMainConfig>().as_mut().expect("shared dict main config") };
|
|
|
|
// SAFETY:
|
|
// - `cf.args` is guaranteed to be a pointer to an array with 3 elements (NGX_CONF_TAKE2).
|
|
// - The pointers are well-aligned by construction method (`ngx_palloc`).
|
|
debug_assert!(!cf.args.is_null() && unsafe { (*cf.args).nelts >= 3 });
|
|
let args = unsafe { (*cf.args).as_slice_mut() };
|
|
|
|
let mut name: ngx_str_t = args[1];
|
|
let size = unsafe { ngx_parse_size(&raw mut args[2]) };
|
|
if size == -1 {
|
|
return NGX_CONF_ERROR;
|
|
}
|
|
|
|
smcf.shm_zone = unsafe {
|
|
ngx_shared_memory_add(
|
|
cf,
|
|
&raw mut name,
|
|
size as usize,
|
|
(&raw mut ngx_http_shared_dict_module).cast(),
|
|
)
|
|
};
|
|
|
|
let Some(shm_zone) = (unsafe { smcf.shm_zone.as_mut() }) else {
|
|
return NGX_CONF_ERROR;
|
|
};
|
|
|
|
shm_zone.init = Some(ngx_http_shared_dict_zone_init);
|
|
shm_zone.data = ptr::from_mut(smcf).cast();
|
|
|
|
NGX_CONF_OK
|
|
}
|
|
|
|
fn ngx_http_shared_dict_get_shared(shm_zone: &mut ngx_shm_zone_t) -> Result<&SharedData, Status> {
|
|
let mut alloc = unsafe { SlabPool::from_shm_zone(shm_zone) }.ok_or(Status::NGX_ERROR)?;
|
|
|
|
if alloc.as_mut().data.is_null() {
|
|
let shared: RbTreeMap<NgxString<SlabPool>, NgxString<SlabPool>, SlabPool> =
|
|
RbTreeMap::try_new_in(alloc.clone()).map_err(|_| Status::NGX_ERROR)?;
|
|
|
|
let shared = ngx::sync::RwLock::new(shared);
|
|
|
|
alloc.as_mut().data = ngx::allocator::allocate(shared, &alloc)
|
|
.map_err(|_| Status::NGX_ERROR)?
|
|
.as_ptr()
|
|
.cast();
|
|
}
|
|
|
|
unsafe { alloc.as_ref().data.cast::<SharedData>().as_ref().ok_or(Status::NGX_ERROR) }
|
|
}
|
|
|
|
extern "C" fn ngx_http_shared_dict_zone_init(
|
|
shm_zone: *mut ngx_shm_zone_t,
|
|
_data: *mut c_void,
|
|
) -> ngx_int_t {
|
|
let shm_zone = unsafe { &mut *shm_zone };
|
|
|
|
match ngx_http_shared_dict_get_shared(shm_zone) {
|
|
Err(e) => e.into(),
|
|
Ok(_) => Status::NGX_OK.into(),
|
|
}
|
|
}
|
|
|
|
extern "C" fn ngx_http_shared_dict_add_variable(
|
|
cf: *mut ngx_conf_t,
|
|
_cmd: *mut ngx_command_t,
|
|
_conf: *mut c_void,
|
|
) -> *mut c_char {
|
|
// SAFETY: configuration handlers always receive a valid `cf` pointer.
|
|
let cf = unsafe { cf.as_mut().unwrap() };
|
|
let pool = unsafe { Pool::from_ngx_pool(cf.pool) };
|
|
|
|
let key = pool.calloc_type::<ngx_http_complex_value_t>();
|
|
if key.is_null() {
|
|
return NGX_CONF_ERROR;
|
|
}
|
|
|
|
// SAFETY:
|
|
// - `cf.args` is guaranteed to be a pointer to an array with 3 elements (NGX_CONF_TAKE2).
|
|
// - The pointers are well-aligned by construction method (`ngx_palloc`).
|
|
debug_assert!(!cf.args.is_null() && unsafe { (*cf.args).nelts >= 3 });
|
|
let args = unsafe { (*cf.args).as_slice_mut() };
|
|
|
|
let mut ccv: ngx_http_compile_complex_value_t = unsafe { mem::zeroed() };
|
|
ccv.cf = cf;
|
|
ccv.value = &raw mut args[1];
|
|
ccv.complex_value = key;
|
|
|
|
if unsafe { nginx_sys::ngx_http_compile_complex_value(&raw mut ccv) } != Status::NGX_OK.into() {
|
|
return NGX_CONF_ERROR;
|
|
}
|
|
|
|
let mut name = args[2];
|
|
|
|
if name.as_bytes()[0] != b'$' {
|
|
ngx_conf_log_error!(NGX_LOG_EMERG, cf, "invalid variable name \"{name}\"");
|
|
return NGX_CONF_ERROR;
|
|
}
|
|
|
|
name.data = unsafe { name.data.add(1) };
|
|
name.len -= 1;
|
|
|
|
let var = unsafe {
|
|
ngx_http_add_variable(
|
|
cf,
|
|
&raw mut name,
|
|
(NGX_HTTP_VAR_CHANGEABLE | NGX_HTTP_VAR_NOCACHEABLE) as ngx_uint_t,
|
|
)
|
|
};
|
|
if var.is_null() {
|
|
return NGX_CONF_ERROR;
|
|
}
|
|
|
|
unsafe {
|
|
(*var).get_handler = Some(ngx_http_shared_dict_get_variable);
|
|
(*var).set_handler = Some(ngx_http_shared_dict_set_variable);
|
|
(*var).data = key as usize;
|
|
}
|
|
|
|
NGX_CONF_OK
|
|
}
|
|
|
|
extern "C" fn ngx_http_shared_dict_get_variable(
|
|
r: *mut ngx_http_request_t,
|
|
v: *mut ngx_http_variable_value_t,
|
|
data: usize,
|
|
) -> ngx_int_t {
|
|
let r = unsafe { &mut *r };
|
|
let v = unsafe { &mut *v };
|
|
let smcf = HttpSharedDictModule::main_conf_mut(r).expect("shared dict main config");
|
|
|
|
let mut key = ngx_str_t::empty();
|
|
if unsafe { ngx_http_complex_value(r, data as _, &raw mut key) } != Status::NGX_OK.into() {
|
|
return Status::NGX_ERROR.into();
|
|
}
|
|
|
|
let key = unsafe { NgxStr::from_ngx_str(key) };
|
|
|
|
let Ok(shared) = ngx_http_shared_dict_get_shared(unsafe { &mut *smcf.shm_zone }) else {
|
|
return Status::NGX_ERROR.into();
|
|
};
|
|
|
|
let value =
|
|
shared.read().get(key).and_then(|x| unsafe { ngx_str_t::from_bytes(r.pool, x.as_bytes()) });
|
|
|
|
ngx_log_debug!(
|
|
unsafe { (*r.connection).log },
|
|
"shared dict: get \"{}\" -> {:?} w:{} p:{}",
|
|
key,
|
|
value.as_ref().map(|x| unsafe { NgxStr::from_ngx_str(*x) }),
|
|
unsafe { nginx_sys::ngx_worker },
|
|
unsafe { nginx_sys::ngx_pid },
|
|
);
|
|
|
|
let Some(value) = value else {
|
|
v.set_not_found(1);
|
|
return Status::NGX_ERROR.into();
|
|
};
|
|
|
|
v.data = value.data;
|
|
v.set_len(value.len as _);
|
|
|
|
v.set_valid(1);
|
|
v.set_no_cacheable(0);
|
|
v.set_not_found(0);
|
|
|
|
Status::NGX_OK.into()
|
|
}
|
|
|
|
extern "C" fn ngx_http_shared_dict_set_variable(
|
|
r: *mut ngx_http_request_t,
|
|
v: *mut ngx_http_variable_value_t,
|
|
data: usize,
|
|
) {
|
|
let r = unsafe { &mut *r };
|
|
let v = unsafe { &mut *v };
|
|
let smcf = HttpSharedDictModule::main_conf_mut(r).expect("shared dict main config");
|
|
let mut key = ngx_str_t::empty();
|
|
|
|
if unsafe { ngx_http_complex_value(r, data as _, &raw mut key) } != Status::NGX_OK.into() {
|
|
return;
|
|
}
|
|
|
|
let Ok(shared) = ngx_http_shared_dict_get_shared(unsafe { &mut *smcf.shm_zone }) else {
|
|
return;
|
|
};
|
|
|
|
if r.method == NGX_HTTP_DELETE as _ {
|
|
let key = unsafe { NgxStr::from_ngx_str(key) };
|
|
|
|
ngx_log_debug!(
|
|
unsafe { (*r.connection).log },
|
|
"shared dict: delete \"{}\" w:{} p:{}",
|
|
key,
|
|
unsafe { nginx_sys::ngx_worker },
|
|
unsafe { nginx_sys::ngx_pid },
|
|
);
|
|
|
|
let _ = shared.write().remove(key);
|
|
} else {
|
|
let alloc = unsafe { SlabPool::from_shm_zone(&*smcf.shm_zone).expect("slab pool") };
|
|
|
|
let Ok(key) = NgxString::try_from_bytes_in(key.as_bytes(), alloc.clone()) else {
|
|
return;
|
|
};
|
|
|
|
let Ok(value) = NgxString::try_from_bytes_in(v.as_bytes(), alloc.clone()) else {
|
|
return;
|
|
};
|
|
|
|
ngx_log_debug!(
|
|
unsafe { (*r.connection).log },
|
|
"shared dict: set \"{}\" -> \"{}\" w:{} p:{}",
|
|
key,
|
|
value,
|
|
unsafe { nginx_sys::ngx_worker },
|
|
unsafe { nginx_sys::ngx_pid },
|
|
);
|
|
|
|
let _ = shared.write().try_insert(key, value);
|
|
}
|
|
}
|
|
|
|
extern "C" fn ngx_http_shared_dict_get_entries(
|
|
r: *mut ngx_http_request_t,
|
|
v: *mut ngx_http_variable_value_t,
|
|
_data: usize,
|
|
) -> ngx_int_t {
|
|
use core::fmt::Write;
|
|
|
|
let r = unsafe { &mut *r };
|
|
let v = unsafe { &mut *v };
|
|
let pool = unsafe { Pool::from_ngx_pool(r.pool) };
|
|
let smcf = HttpSharedDictModule::main_conf_mut(r).expect("shared dict main config");
|
|
|
|
ngx_log_debug!(unsafe { (*r.connection).log }, "shared dict: get all entries");
|
|
|
|
let Ok(shared) = ngx_http_shared_dict_get_shared(unsafe { &mut *smcf.shm_zone }) else {
|
|
return Status::NGX_ERROR.into();
|
|
};
|
|
|
|
let mut str = NgxString::new_in(pool);
|
|
{
|
|
let dict = shared.read();
|
|
|
|
let mut len: usize = 0;
|
|
let mut values: usize = 0;
|
|
|
|
for (key, value) in dict.iter() {
|
|
len += key.len() + value.len() + b" = ; ".len();
|
|
values += 1;
|
|
}
|
|
|
|
len += values.checked_ilog10().unwrap_or(0) as usize + b"0; ".len();
|
|
|
|
if str.try_reserve(len).is_err() {
|
|
return Status::NGX_ERROR.into();
|
|
}
|
|
|
|
if write!(str, "{values}; ").is_err() {
|
|
return Status::NGX_ERROR.into();
|
|
}
|
|
|
|
for (key, value) in dict.iter() {
|
|
if write!(str, "{key} = {value}; ").is_err() {
|
|
return Status::NGX_ERROR.into();
|
|
}
|
|
}
|
|
}
|
|
|
|
// The string is allocated on the `ngx_pool_t` and will be freed with the request.
|
|
let (data, len, _, _) = str.into_raw_parts();
|
|
|
|
v.data = data;
|
|
v.set_len(len as _);
|
|
|
|
v.set_valid(1);
|
|
v.set_no_cacheable(1);
|
|
v.set_not_found(0);
|
|
|
|
Status::NGX_OK.into()
|
|
}
|
|
|
|
extern "C" fn ngx_http_shared_dict_set_entries(
|
|
r: *mut ngx_http_request_t,
|
|
_v: *mut ngx_http_variable_value_t,
|
|
_data: usize,
|
|
) {
|
|
let r = unsafe { &mut *r };
|
|
let smcf = HttpSharedDictModule::main_conf_mut(r).expect("shared dict main config");
|
|
|
|
ngx_log_debug!(unsafe { (*r.connection).log }, "shared dict: clear");
|
|
|
|
let Ok(shared) = ngx_http_shared_dict_get_shared(unsafe { &mut *smcf.shm_zone }) else {
|
|
return;
|
|
};
|
|
|
|
let Ok(tree) = RbTreeMap::try_new_in(shared.read().allocator().clone()) else {
|
|
return;
|
|
};
|
|
|
|
// This would check both .clear() and the drop implementation
|
|
*shared.write() = tree;
|
|
// shared.write().clear()
|
|
}
|