#include "sleela_server.hpp" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef _WIN32 #define NOMINMAX #include #include #pragma comment(lib,"Ws2_32.lib") using socket_len_t=int; #else #include #include #include #include #include using socket_len_t=socklen_t; #endif namespace sleela::server { namespace { constexpr std::uint32_t MAGIC=0x534C504B; constexpr std::uint8_t WIRE_VERSION=1; constexpr std::size_t FIXED_HEADER=40; std::uint16_t be16(const std::uint8_t*p){return (std::uint16_t)((p[0]<<8)|p[1]);} std::uint32_t be32(const std::uint8_t*p){return ((std::uint32_t)p[0]<<24)|((std::uint32_t)p[1]<<16)|((std::uint32_t)p[2]<<8)|p[3];} std::uint64_t be64(const std::uint8_t*p){std::uint64_t v=0;for(int i=0;i<8;++i)v=(v<<8)|p[i];return v;} bool known_grade(std::uint8_t g){return g>=1&&g<=9;} bool printable(const std::string&s){for(unsigned char c:s)if(c<0x20&&c!='\t')return false;return true;} template bool parse_uint(const std::string& text, T& out) { if (text.empty()) return false; T value{}; const auto r = std::from_chars(text.data(), text.data() + text.size(), value, 10); if (r.ec != std::errc{} || r.ptr != text.data() + text.size()) return false; out = value; return true; } std::string esc(const std::string&s){std::string o;for(unsigned char c:s){if(c=='\\'||c=='"'){o+='\\';o+=(char)c;}else if(c=='\n')o+="\\n";else if(c=='\r')o+="\\r";else if(c<0x20){std::ostringstream x;x<<"\\u"<lock(mutex_);std::ofstream f(cfg_.log_file,std::ios::app);std::ostream&os=f?f:std::cerr; auto tt=std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());char ts[32];std::strftime(ts,sizeof(ts),"%Y-%m-%dT%H:%M:%SZ",std::gmtime(&tt)); os<<"{\"time\":\"" << ts << "\",\"level\":\"" << level_name(l) << "\",\"event\":\"" << esc(e) << "\""; if(p)os<<",\"grade\":"<<(int)p->grade<<",\"stream\":"<stream_id<<",\"request\":"<request_id<<",\"sequence\":"<sequence<<",\"service\":\"" << esc(p->service_id) << "\",\"operation\":\"" << esc(p->operation_id) << "\""<<(cfg_.log_payload?",\"payload_bytes\":"+std::to_string(p->payload.size()):""); if(d)os<<",\"status\":"<status<<",\"heuristic_score\":"<heuristic_score<<",\"reason\":\"" << esc(d->reason) << "\""; if(!detail.empty())os<<",\"detail\":\"" << esc(detail) << "\"";os<<"}\n"; } PacketInspector::PacketInspector(const ServerConfig&c):cfg_(c){} Decision PacketInspector::inspect(const Packet&p,std::size_t wire,std::uint64_t rate,std::uint64_t failures)const{ if(cfg_.require_known_grade&&!known_grade(p.grade))return{false,400,Severity::WARN,"unknown_protocol_grade",.9}; if(wire>cfg_.max_packet_bytes)return{false,413,Severity::WARN,"packet_too_large",1.0}; if(p.service_id.empty()||p.operation_id.empty())return{false,422,Severity::WARN,"missing_routing_fields",.8}; if(p.service_id.size()>256||p.operation_id.size()>256)return{false,422,Severity::WARN,"routing_field_too_long",.9}; if(!printable(p.service_id)||!printable(p.operation_id))return{false,422,Severity::WARN,"non_printable_routing_field",.95}; if(!cfg_.allowed_services.empty()&&!cfg_.allowed_services.count(p.service_id))return{false,403,Severity::NOTICE,"service_not_allowlisted",.35}; if(cfg_.denied_services.count(p.service_id))return{false,403,Severity::NOTICE,"service_denied",.7}; if(cfg_.denied_operations.count(p.operation_id))return{false,403,Severity::NOTICE,"operation_denied",.7}; if(p.payload.size()>cfg_.max_payload_bytes)return{false,413,Severity::WARN,"payload_too_large",1.0}; if(rate>cfg_.max_packets_per_second)return{false,429,Severity::ALERT,"packet_rate_exceeded",.95}; double score=0;if(failures>cfg_.max_failures_per_minute)score+=.15; if(p.grade>=8&&p.fields.find("SOURCE")==p.fields.end())score+=.20; if(p.grade>=9&&p.fields.find("DARK-BAND-NAME")==p.fields.end())score+=.10; if(p.sequence==0&&p.stream_id!=0)score+=.10; Severity sev=Severity::INFO;std::string reason="accepted"; if(score>=.75){sev=Severity::ALERT;reason="heuristic_threshold";}else if(score>=.40){sev=Severity::WARN;reason="heuristic_anomaly";} return{true,200,sev,reason,score}; } bool PacketInspector::parse_headers(const std::string&block,Packet&p,std::string&err){ Packet candidate=p; std::istringstream in(block);std::string line;std::unordered_setseen; try{while(std::getline(in,line)){if(!line.empty()&&line.back()=='\r')line.pop_back();if(line.empty())continue;auto eq=line.find('=');if(eq==std::string::npos||eq==0){err="bad_header";return false;}std::string k=line.substr(0,eq),v=line.substr(eq+1);if(k.size()>64||v.size()>4096||!printable(k)||k.find_first_not_of("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.")!=std::string::npos||!printable(v)){err="header_bounds";return false;}if(!seen.insert(k).second){err="duplicate_header";return false;} if(k=="SERVICE-ID")candidate.service_id=v; else if(k=="OP-ID")candidate.operation_id=v; else if(k=="PROTOCOL-GRADE"){std::uint64_t n=0;if(!parse_uint(v,n)||n>255){err="invalid_protocol_grade";return false;}candidate.grade=static_cast(n);} else if(k=="FLAGS"){std::uint64_t n=0;if(!parse_uint(v,n)||n>65535){err="invalid_flags";return false;}candidate.flags=static_cast(n);} else if(k=="STREAM-ID"){if(!parse_uint(v,candidate.stream_id)){err="invalid_stream_id";return false;}} else if(k=="REQUEST-ID"){if(!parse_uint(v,candidate.request_id)){err="invalid_request_id";return false;}} else if(k=="SEQUENCE"){if(!parse_uint(v,candidate.sequence)){err="invalid_sequence";return false;}} else candidate.fields.emplace(std::move(k),std::move(v)); } }catch(...){err="invalid_header";return false;}if(candidate.grade==0||candidate.service_id.empty()||candidate.operation_id.empty()){err="missing_required_header";return false;} p=std::move(candidate); return true; } SleelaServer::SleelaServer(ServerConfig c):config_(std::move(c)),logger_(config_),inspector_(config_),packet_logger_("logs"){} SleelaServer::~SleelaServer(){stop();} std::string SleelaServer::handler_key(const std::string& service,const std::string& operation){return service+char(31)+operation;} bool SleelaServer::register_handler(const std::string& service,const std::string& operation,ServiceHandler handler){ if(service.empty()||operation.empty()||service.size()>256||operation.size()>256||!handler||!printable(service)||!printable(operation))return false; std::lock_guard lock(handlers_mutex_); return handlers_.emplace(handler_key(service,operation),std::move(handler)).second; } bool SleelaServer::start(){ std::lock_guard state_lock(state_mutex_); if(running_.load())return true; if(config_.port==0 || config_.max_connections==0 || config_.max_connections>65535 || config_.max_packet_bytesconfig_.max_packet_bytes-FIXED_HEADER || config_.max_payload_bytes>config_.max_packet_bytes || config_.idle_timeout_seconds==0 || config_.max_packets_per_second==0 || config_.tls_certificate_file.empty()!=config_.tls_private_key_file.empty() || config_.tls_certificate_file.empty()!=config_.tls_client_ca_file.empty()) { logger_.write(Severity::ERROR,"invalid_server_configuration",nullptr,nullptr); return false; } const bool tls_enabled=!config_.tls_certificate_file.empty(); if(config_.bind_address!="127.0.0.1" && config_.bind_address.rfind("127.",0)!=0 && !tls_enabled){logger_.write(Severity::ERROR,"remote_bind_requires_tls",nullptr,nullptr);return false;} if(tls_enabled && (config_.allowed_peer_identities.empty()||config_.identity_permissions.empty())){logger_.write(Severity::ERROR,"tls_identity_policy_missing",nullptr,nullptr);return false;} if(tls_enabled){ tls_context_=SSL_CTX_new(TLS_server_method()); if(!tls_context_ || SSL_CTX_set_min_proto_version(tls_context_,TLS1_3_VERSION)!=1 || SSL_CTX_set_max_proto_version(tls_context_,TLS1_3_VERSION)!=1 || SSL_CTX_set1_groups_list(tls_context_,"X25519:P-256:P-384")!=1 || SSL_CTX_use_certificate_chain_file(tls_context_,config_.tls_certificate_file.c_str())!=1 || SSL_CTX_use_PrivateKey_file(tls_context_,config_.tls_private_key_file.c_str(),SSL_FILETYPE_PEM)!=1 || SSL_CTX_check_private_key(tls_context_)!=1 || SSL_CTX_load_verify_locations(tls_context_,config_.tls_client_ca_file.c_str(),nullptr)!=1){ if(tls_context_){SSL_CTX_free(tls_context_);tls_context_=nullptr;} logger_.write(Severity::ERROR,"tls_configuration_failed",nullptr,nullptr);return false; } SSL_CTX_set_verify(tls_context_,SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT,nullptr); SSL_CTX_set_verify_depth(tls_context_,4); } #ifdef _WIN32 WSADATA w{};if(WSAStartup(MAKEWORD(2,2),&w)!=0){if(tls_context_){SSL_CTX_free(tls_context_);tls_context_=nullptr;}return false;}winsock_started_=true; #endif listen_fd_=(int)::socket(AF_INET,SOCK_STREAM,0);if(listen_fd_<0){if(tls_context_){SSL_CTX_free(tls_context_);tls_context_=nullptr;} #ifdef _WIN32 if(winsock_started_){WSACleanup();winsock_started_=false;} #endif return false;}int one=1;setsockopt(listen_fd_,SOL_SOCKET,SO_REUSEADDR,(char*)&one,sizeof(one)); sockaddr_in a{};a.sin_family=AF_INET;a.sin_port=htons(config_.port);if(config_.bind_address=="0.0.0.0")a.sin_addr.s_addr=htonl(INADDR_ANY);else if(inet_pton(AF_INET,config_.bind_address.c_str(),&a.sin_addr)!=1){close_socket(listen_fd_);listen_fd_=-1;if(tls_context_){SSL_CTX_free(tls_context_);tls_context_=nullptr;} #ifdef _WIN32 if(winsock_started_){WSACleanup();winsock_started_=false;} #endif return false;} if(::bind(listen_fd_,(sockaddr*)&a,sizeof(a))!=0){close_socket(listen_fd_);listen_fd_=-1;if(tls_context_){SSL_CTX_free(tls_context_);tls_context_=nullptr;}return false;}if(::listen(listen_fd_,(int)config_.max_connections)!=0){close_socket(listen_fd_);listen_fd_=-1;if(tls_context_){SSL_CTX_free(tls_context_);tls_context_=nullptr;}return false;}running_=true; sleela::LoggerLogic logic; logic.log_sent=true; logic.log_received=true; logic.minimum_severity=sleela::LogSeverity::Info; logic.minimum_admission=sleela::LogAdmission::Accepted; packet_logger_.set_logic(logic); if(!packet_logger_.open()){ logger_.write(Severity::ERROR,"packet_logger_open_failed",nullptr,nullptr); } logger_.write(Severity::NOTICE,"server_started",nullptr,nullptr);return true; } void SleelaServer::run(){ bool expected=false;if(!run_active_.compare_exchange_strong(expected,true))throw std::runtime_error("SLeeLa server run already active"); if(!running_.load()&&!start()){run_active_.store(false);throw std::runtime_error("SLeeLa server start failed");} while(running_.load()){ sockaddr_in p{};socket_len_t n=sizeof(p); int fd=(int)::accept(listen_fd_,(sockaddr*)&p,&n); if(fd<0){if(!running_.load())break;continue;} const auto previous=active_connections_.fetch_add(1); if(previous>=config_.max_connections){ active_connections_.fetch_sub(1); write_status(fd,nullptr,503,"connection_limit"); close_socket(fd); logger_.write(Severity::NOTICE,"connection_limit_reached",nullptr,nullptr); continue; } char h[INET_ADDRSTRLEN]{};inet_ntop(AF_INET,&p.sin_addr,h,sizeof(h)); {std::lock_guard state_lock(state_mutex_);if(!running_.load()){close_socket(fd);active_connections_.fetch_sub(1);break;}client_sockets_.insert(fd);} std::lock_guard workers_lock(workers_mutex_); // Bound retained thread handles even during long-lived sequential workloads. if(workers_.size()>=config_.max_connections*2){ auto old=std::move(workers_.front());workers_.erase(workers_.begin()); if(old.joinable())old.join(); } workers_.emplace_back(&SleelaServer::client_loop,this,fd,std::string(h)); } { std::lock_guard workers_lock(workers_mutex_); for(auto& worker:workers_)if(worker.joinable())worker.join(); workers_.clear(); } packet_logger_.close(); {std::lock_guard state_lock(state_mutex_);if(listen_fd_>=0){close_socket(listen_fd_);listen_fd_=-1;}if(tls_context_){SSL_CTX_free(tls_context_);tls_context_=nullptr;} #ifdef _WIN32 if(winsock_started_){WSACleanup();winsock_started_=false;} #endif } run_active_.store(false); } void SleelaServer::stop(){ std::lock_guardl(state_mutex_);running_.store(false);for(int client:client_sockets_){ #ifdef _WIN32 shutdown(client,SD_BOTH); #else shutdown(client,SHUT_RDWR); #endif } if(listen_fd_>=0){ #ifdef _WIN32 shutdown(listen_fd_,SD_BOTH); #else shutdown(listen_fd_,SHUT_RDWR); #endif if(!run_active_.load()){close_socket(listen_fd_);listen_fd_=-1;if(tls_context_){SSL_CTX_free(tls_context_);tls_context_=nullptr;} #ifdef _WIN32 if(winsock_started_){WSACleanup();winsock_started_=false;} #endif }} } bool SleelaServer::running()const noexcept{return running_.load();} bool SleelaServer::read_exact(int fd,SSL* ssl,void*dst,std::size_t bytes,std::uint32_t ms){ auto* p=static_cast(dst); std::size_t got=0; const auto deadline=std::chrono::steady_clock::now()+std::chrono::milliseconds(ms); while(got=deadline)return false; const auto remaining=std::chrono::duration_cast(deadline-now); const auto us=remaining.count(); fd_set set;FD_ZERO(&set);FD_SET(fd,&set); timeval tv{static_cast(us/1000000),static_cast(us%1000000)}; if((!ssl || SSL_pending(ssl)==0) && select(fd+1,&set,nullptr,nullptr,&tv)<=0)return false; int n=0; if(ssl)n=SSL_read(ssl,p+got,static_cast(std::min(bytes-got,static_cast(std::numeric_limits::max())))); else { #ifdef _WIN32 n=recv(fd,(char*)p+got,(int)(bytes-got),0); #else n=(int)recv(fd,p+got,bytes-got,0); #endif } if(n<=0)return false;got+=(std::size_t)n;}return true;} bool SleelaServer::read_packet(int fd,SSL* ssl,Packet&p,std::size_t&wire,std::string&err){std::arrayh{};if(!read_exact(fd,ssl,h.data(),h.size(),config_.idle_timeout_seconds*1000U)){err="header_timeout_or_eof";return false;}if(be32(h.data())!=MAGIC||h[4]!=WIRE_VERSION){err="bad_magic_or_wire_version";return false;}std::uint32_t hl=be32(h.data()+8),pl=be32(h.data()+12);std::uint64_t total=FIXED_HEADER+(std::uint64_t)hl+pl;if(be16(h.data()+6)!=0){err="unsupported_flags";return false;}if(hl>config_.max_header_bytes||pl>config_.max_payload_bytes||total>config_.max_packet_bytes){err="frame_exceeds_limits";return false;} p.grade=h[5];p.flags=be16(h.data()+6);p.stream_id=be64(h.data()+16);p.request_id=be64(h.data()+24);p.sequence=be64(h.data()+32);std::string hs(hl,'\0');if(hl&&!read_exact(fd,ssl,hs.data(),hl,config_.idle_timeout_seconds*1000U)){err="header_body_truncated";return false;}if(!PacketInspector::parse_headers(hs,p,err))return false;if(p.grade!=h[5]){err="grade_mismatch";return false;}if(p.flags!=be16(h.data()+6)){err="flags_mismatch";return false;}p.payload.resize(pl);if(pl&&!read_exact(fd,ssl,p.payload.data(),pl,config_.idle_timeout_seconds*1000U)){err="payload_truncated";return false;}wire=(std::size_t)total;return true;} bool SleelaServer::write_status(int fd,SSL* ssl,int status,const char*reason){ const std::string s="SLPK/1 "+std::to_string(status)+" "+reason+"\n"; std::size_t sent=0; while(sent(s.size()-sent)); else { #ifdef _WIN32 n=send(fd,s.data()+sent,static_cast(s.size()-sent),0); #else n=static_cast(send(fd,s.data()+sent,s.size()-sent,MSG_NOSIGNAL)); #endif } if(n<0){ #ifndef _WIN32 if(errno==EINTR)continue; #endif return false; } if(n==0)return false; sent+=static_cast(n); } return true; } void SleelaServer::client_loop(int fd,std::string peer){ SSL* ssl=nullptr; std::string identity; if(tls_context_){ #ifdef _WIN32 DWORD handshake_timeout=10000;setsockopt(fd,SOL_SOCKET,SO_RCVTIMEO,reinterpret_cast(&handshake_timeout),sizeof(handshake_timeout)); #else timeval handshake_timeout{10,0};setsockopt(fd,SOL_SOCKET,SO_RCVTIMEO,&handshake_timeout,sizeof(handshake_timeout)); #endif ssl=SSL_new(tls_context_); if(!ssl || SSL_set_fd(ssl,fd)!=1 || SSL_accept(ssl)!=1){ logger_.write(Severity::WARN,"tls_handshake_failed",nullptr,nullptr,peer); if(ssl)SSL_free(ssl);close_socket(fd);{std::lock_guard lock(state_mutex_);client_sockets_.erase(fd);}active_connections_.fetch_sub(1);return; } #ifdef _WIN32 DWORD no_timeout=0;setsockopt(fd,SOL_SOCKET,SO_RCVTIMEO,reinterpret_cast(&no_timeout),sizeof(no_timeout)); #else timeval no_timeout{0,0};setsockopt(fd,SOL_SOCKET,SO_RCVTIMEO,&no_timeout,sizeof(no_timeout)); #endif X509* cert=SSL_get_peer_certificate(ssl); if(cert){X509_NAME* subject=X509_get_subject_name(cert);int index=X509_NAME_get_index_by_NID(subject,NID_commonName,-1);if(index>=0){X509_NAME_ENTRY* entry=X509_NAME_get_entry(subject,index);ASN1_STRING* data=X509_NAME_ENTRY_get_data(entry);unsigned char* utf8=nullptr;int n=ASN1_STRING_to_UTF8(&utf8,data);if(n>0&&static_cast(n)<=256)identity.assign(reinterpret_cast(utf8),static_cast(n));OPENSSL_free(utf8);}X509_free(cert);} if(identity.empty()||!config_.allowed_peer_identities.count(identity)){ logger_.write(Severity::WARN,"tls_identity_not_allowlisted",nullptr,nullptr,peer); SSL_shutdown(ssl);SSL_free(ssl);close_socket(fd);{std::lock_guard lock(state_mutex_);client_sockets_.erase(fd);}active_connections_.fetch_sub(1);return; } } struct ActiveGuard{std::atomic& count;~ActiveGuard(){count.fetch_sub(1);}} active_guard{active_connections_};std::uint64_t packets=0,failures=0;auto started=std::chrono::steady_clock::now();logger_.write(Severity::DEBUG,"client_connected",nullptr,nullptr,peer+ (identity.empty()?"":(" identity="+identity))); while(running_.load()){Packet p;std::size_t wire=0;std::string err;if(!read_packet(fd,ssl,p,wire,err)){++failures;logger_.write(Severity::WARN,"packet_rejected",nullptr,nullptr,peer+":"+err);write_status(fd,ssl,400,err.c_str());break;}++packets; packet_logger_.record_received(peer,"SLeeLa-WIRE/"+std::to_string((int)p.grade),p.stream_id,p.request_id,p.sequence,wire,"raw_socket_to_sleela_server"); auto sec=std::chrono::duration_cast(std::chrono::steady_clock::now()-started).count();std::uint64_t rate=sec==0?packets:packets/(std::uint64_t)sec;Decision d=inspector_.inspect(p,wire,rate,failures);if(d.accept&&tls_context_){auto it=config_.identity_permissions.find(identity);const std::string permission=handler_key(p.service_id,p.operation_id);if(it==config_.identity_permissions.end()||!it->second.count(permission))d={false,403,Severity::NOTICE,"identity_not_authorized",.7};}logger_.write(d.severity,d.accept?"packet_accepted":"packet_rejected",&p,&d,peer);if(!d.accept){write_status(fd,ssl,d.status,d.reason.c_str());break;}ServiceHandler handler;{std::lock_guard lock(handlers_mutex_);auto it=handlers_.find(handler_key(p.service_id,p.operation_id));if(it!=handlers_.end())handler=it->second;} ServiceResponse response; if(!handler){response.status=501;response.reason="service_not_implemented";}else{try{response=handler(p);}catch(...){response.status=500;response.reason="handler_error";}} if(response.status<200||response.status>599||response.reason.empty()||response.reason.find_first_of(" \r\n")!=std::string::npos){response.status=500;response.reason="invalid_handler_response";} if(!write_status(fd,ssl,response.status,response.reason.c_str()))break; packet_logger_.record_sent(peer,"SLeeLa-WIRE/"+std::to_string((int)p.grade),p.stream_id,p.request_id,p.sequence,(std::string("SLPK/1 ")+std::to_string(response.status)+" "+response.reason+"\n").size(),"server_to_os_socket");} if(ssl){SSL_shutdown(ssl);SSL_free(ssl);}close_socket(fd);{std::lock_guard state_lock(state_mutex_);client_sockets_.erase(fd);}logger_.write(Severity::DEBUG,"client_disconnected",nullptr,nullptr,peer);} void SleelaServer::close_socket(int fd){if(fd<0)return; #ifdef _WIN32 closesocket(fd); #else ::close(fd); #endif } }