Files
sso/source/rust/vendor/ngx-rust/examples/shared_dict.rs
T
ssw c8a02b8c49 feat: 从网关项目剥离为独立 SSO 统一认证服务
定位:身份层(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、用户管理界面)
2026-09-12 21:42:06 +08:00

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()
}