This tutorial explains what SSO and CAS are, outlines the required development environment, walks through downloading, building, and deploying the CAS Server, shows how to configure the server and client (including disabling HTTPS for testing), and demonstrates successful cross‑application authentication with code examples.
This article provides a comprehensive tutorial on implementing Single Sign-On using the CAS (Central Authentication Service) framework, covering the concepts of SSO and CAS, required development environment, server-side deployment, client configuration, and end‑to‑end testing with detailed code examples.
This article provides a comprehensive tutorial on implementing Single Sign‑On using the open‑source CAS solution, covering the concepts of SSO and CAS, required development environment, server‑side deployment, client integration with Spring Boot, configuration details, and a complete end‑to‑end testing workflow.
This article explains how a large, monolithic internal operations management system was refactored into a micro‑frontend architecture, detailing the container framework, SSO integration, resource‑permission system, communication mechanisms, and the resulting benefits for independent team development and performance.
Baidu’s ToB Account Permission Platform provides a unified, configurable login and permission service—including multi‑tenant account management, SSO, OAuth, and the GD‑RBAC model—delivering secure, high‑performance access for over ten million enterprise accounts across multiple product lines.
This article provides a detailed, step‑by‑step tutorial on building a Spring Security‑based Single Sign‑On solution using JWT, covering SSO concepts, JWT structure, RSA encryption, custom authentication filters, Maven project setup, configuration files, and full code examples for both authentication and resource services.
This article provides a comprehensive 20,000‑word guide on building a Spring Security‑based single sign‑on solution using JWT, covering the SSO concept, token structure, RSA encryption, Maven project setup, configuration files, custom authentication and verification filters, and end‑to‑end testing with Postman.
This article explains what JSON Web Token (JWT) is, its underlying mechanism and data structure, compares it with traditional session authentication, and demonstrates how JWT can be used for cross‑domain single sign‑on, access/refresh token handling, and secure API authentication.
This article explains the principles and workflow of Single Sign-On (SSO) using OAuth2.0, illustrates the process with a real‑life scenario, compares multi‑point and single‑point login, and provides a complete Spring Boot example for building an authorization server, client, and role‑based access control in micro‑service architectures.
This article provides a detailed overview of authentication mechanisms, covering UI login methods such as Basic, LDAP, OAuth, Kerberos, and SSO, API call verification techniques like HMAC and JWT, and practical design guidelines for implementing SSO with CAS in micro‑service architectures.
This article explores the challenges of cross‑domain login state sharing, compares JWT, session‑cookie, and SSO solutions such as CAS and OAuth, details their structures, security considerations, and provides a step‑by‑step guide to building a simple SSO demo with code snippets and diagrams.
This article explains the fundamentals of HTTP's stateless nature, session handling in single‑system web apps, the challenges of multi‑system environments, and presents a detailed walkthrough of Single Sign‑On concepts, token‑based authentication flow, global versus local sessions, deployment considerations, and a step‑by‑step Java implementation with code examples.
This article provides an in‑depth overview of authentication, covering both UI login and API call methods such as Basic, LDAP, OAuth, Kerberos, SSO, HMAC, and JWT, and explains how to design secure, cross‑domain authentication components within micro‑service architectures.
This article provides a comprehensive guide to authentication, covering basic username/password login, LDAP, OAuth 2.0, Kerberos, SSO with CAS, as well as API authentication methods like HMAC and JWT, and offers design recommendations for both UI and API security in micro‑service architectures.
This article explains the necessity of Single Sign-On (SSO) in multi‑system environments, traces its origins from monolithic web applications to distributed clusters, and describes common implementation approaches for same‑domain and cross‑domain scenarios, including the use of a central authentication center such as CAS.
This article explains the principles of Single Sign-On using OAuth2.0, illustrates the flow with a real‑world analogy, details HTTP redirection, compares grant types, and provides a complete Spring Boot implementation of an authorization server, client application, and role‑based access control for microservices.
This tutorial walks through the concepts of Single Sign‑On (SSO) and JSON Web Tokens (JWT), then provides a complete Spring Security integration with JWT—including project structure, RSA key handling, utility classes, custom authentication and verification filters, and step‑by‑step testing using Postman.
This article explains the fundamentals of authentication, covering session‑cookie and token methods, their workflows, security considerations, and advanced techniques such as single sign‑on, OAuth2, LDAP, and two‑factor authentication, with practical examples and code snippets.
This article introduces Authelia, an open‑source authentication and authorization server that provides two‑factor authentication and single sign‑on, explains how it integrates with reverse proxies like Nginx, Traefik or HAProxy, outlines installation options, showcases its UI and key security features, and shares its GitHub statistics and link.
GrowingIO’s server-side solution integrates three distinct authentication protocols—OAuth2, LDAP, and CAS—into a unified SSO flow, detailing each protocol’s process, the overall architecture, role of the IAM and Gateway components, and providing configuration and code examples for implementation.
This article explains the evolution from basic web cookies to session management, explores domain sharing, details cookie‑session architecture, introduces single sign‑on methods, and compares the traditional session approach with JWT token authentication, highlighting their advantages, limitations, and implementation considerations.
This article explains the stateless nature of HTTP, the session and cookie mechanisms for single‑system login, the challenges of multi‑system environments, and provides a detailed overview of Single Sign‑On (SSO) concepts, token flow, and step‑by‑step Java code examples for client and server implementations.
This article reviews three leading SaaS user‑management platforms—Okta, Auth0, and Frontegg—detailing their features, advantages, pricing, and differences in multi‑tenant support, social login, and plug‑in capabilities to help developers choose the best solution for their applications.
This article explains the fundamentals of HTTP's stateless nature, session mechanisms, the challenges of multi‑system login, and provides a detailed guide with Java code examples on implementing Single Sign‑On (SSO) including token generation, validation, and global‑local session handling.
This article explains the principles of Single Sign‑On using OAuth2.0, illustrates the flow with a real‑world analogy, and provides a complete SpringBoot implementation for both the authorization server and client, including role‑based permission control and microservice integration.
This article explains a complete CAS-based single sign‑on solution, covering traditional session mechanisms, the CAS architecture, implementation of single sign‑on, session renewal, single logout, and practical extensions for multi‑system integration to ensure secure and seamless user experiences across enterprise applications.
This article explains the stateless nature of HTTP, how session and cookie mechanisms enable login state in a single web system, the challenges of multi‑system environments, and provides a step‑by‑step guide with code examples for building a Java‑based Single Sign‑On solution, including token generation, validation, and logout handling.
Keycloak, Red Hat’s open‑source identity and access management platform, offers a comprehensive SSO solution with extensive protocols, admin UI, Spring Security integration, and customizable features, but its complexity and steep learning curve may pose challenges for smaller projects.
This article explains the stateless nature of HTTP, introduces session and cookie mechanisms for single‑system login, discusses the challenges of multi‑system applications, and provides a step‑by‑step guide with Java code to implement Single Sign‑On (SSO) including login, token verification, global and local sessions, and coordinated logout.
This article explains the fundamentals of single sign‑on in web applications and compares three practical implementations—parent‑domain cookies, a dedicated authentication center, and a front‑end driven LocalStorage solution—detailing their mechanisms, advantages, and limitations.
This article explains the principle of single sign‑on and compares three implementation techniques—parent‑domain cookies, a dedicated authentication centre, and cross‑domain LocalStorage—detailing their mechanisms, advantages, limitations, and providing sample code for the LocalStorage approach.
This article explains the stateless nature of HTTP, how session mechanisms and cookies enable login state, why single-system login fails in multi‑system environments, and provides a step‑by‑step Java implementation of Single Sign‑On with token generation, validation, and logout handling.
This tutorial walks through creating two Django projects, configuring a shared session store (either a common file or Redis) to achieve single sign‑on across them, and provides full code snippets, settings adjustments, and testing steps to demonstrate seamless login synchronization.
This tutorial walks through building a single sign‑on (SSO) system using OAuth2, Spring Security, and JWT, covering preparation, core concepts, Maven dependencies, configuration files, custom login pages, client setup, logout handling, project structure, and a full demonstration.
This article introduces seven open‑source OAuth/SSO solutions—including oauth2‑shiro, tkey, MaxKey, spring‑lhbauth, oauth2, oauthserver, and JustAuth—detailing their features, supported protocols, and repository links to help developers implement secure authentication and token management in web and mobile applications.
This tutorial explains the concept of Single Sign‑On, demonstrates a simple ticket‑based analogy, introduces JWT structure and RSA signing, and walks through a complete Spring Boot implementation—including project layout, Maven dependencies, configuration files, utility classes, custom authentication and verification filters, security configuration, and Postman testing—so readers can build a secure SSO service from scratch.
This article explains the fundamentals of Single Sign-On (SSO) and the CAS framework, outlines suitable use cases, compares three implementation approaches, details key CAS components and ticket types, and walks through a step‑by‑step cross‑domain SSO deployment process.
This article explains three practical Single Sign‑On implementations—parent‑domain cookies, a dedicated authentication center, and cross‑domain LocalStorage—detailing their mechanisms, advantages, limitations, and code examples for secure token sharing across multiple web applications.
The article introduces three single sign‑on mechanisms—stateless HTTP, session‑based, and login state—and compares three practical implementations: using a parent‑domain cookie, deploying an authentication centre, and sharing tokens via LocalStorage with iframe and postMessage, providing code examples and diagrams.
This article explains how Single Sign‑On works in browser‑server applications, compares three implementation methods—parent‑domain cookies, a dedicated authentication center, and cross‑domain LocalStorage with iframe/postMessage—and provides sample code for the latter technique.
This article explains three practical SSO implementation methods—using a parent‑domain cookie, deploying an authentication center, and leveraging LocalStorage with iframe/postMessage—to share session IDs or tokens across multiple web applications, discussing their advantages, limitations, and code examples.
This article explains the principles of Single Sign-On, compares three implementation methods—parent‑domain cookies, a dedicated authentication center, and cross‑domain LocalStorage with token sharing—and provides code examples and practical considerations for each approach.
This article explains three practical methods for achieving Single Sign‑On in web systems—using a parent‑domain cookie, deploying a dedicated authentication center, and leveraging front‑end LocalStorage with iframe postMessage—to share session or token information across multiple domains.
This article explains the stateless nature of HTTP, session and cookie mechanisms, the challenges of multi‑system authentication, and then details the concept, workflow, token handling, and step‑by‑step Java code for building a basic Single Sign‑On solution with login and logout support.
This article explains the fundamentals of HTTP session management, the limitations of cookie-based single-system login, and introduces Single Sign-On (SSO) concepts, including global and local sessions, token-based authentication, and provides step-by-step Java code examples for implementing SSO client and server components.
This article walks through the complete SSO login flow—from the browser request to the SSO server, code exchange, token generation, and front‑end redirection—while detailing front‑end and back‑end code modifications needed for password‑less authentication.
This article explains the fundamentals of Single Sign‑On (SSO), covering same‑origin policy, cookies and sessions, browser login flows, challenges of multi‑system authentication across subdomains and different domains, front‑end cross‑origin techniques, and an overview of the CAS protocol.
This article explains the background, architecture, and step‑by‑step authentication flow of Single Sign‑On systems, covering the classic CAS framework, Java implementation details, and Taobao's extended SSO design with code examples.
This article explains the principles of single sign‑on and compares several practical implementations—including shared session via Redis, OpenID‑based authentication, cookie‑based OpenID storage, and cross‑domain JSONP techniques—while also discussing their limitations and security considerations.
The article explains how the project login system was upgraded to Single Sign-On (SSO), details two performance testing scenarios for single‑user logins, and provides Groovy and Java code examples for concurrent testing, token handling, and CAS credential verification.
This article explores practical approaches to Single Sign‑On, comparing shared Session, OpenID‑based, and cookie‑based implementations, addressing scalability, cross‑domain challenges, and security considerations to help developers choose the right SSO solution for their architecture.
This guide details step‑by‑step configurations for integrating Single Sign‑On (SSO) and WebHook between GitLab and Jenkins, covering GitLab application setup, Jenkins backup and proxy adjustments, plugin installation, token generation, and testing the connection to ensure successful builds.
This article explains the stateless nature of HTTP, the session mechanism used for single‑system login, the challenges of multi‑system applications, and how Single Sign‑On (SSO) solves them by introducing a central authentication server, token‑based authorization, and coordinated logout, with concrete Java code examples.
This article explains the fundamentals of Single Sign‑On (SSO), compares traditional single‑system login with multi‑system authentication, discusses session and cookie challenges, and provides Java Spring code examples for token‑based SSO using Redis and interceptors.
This guide explains how to configure Single Sign‑On (SSO) and WebHook integrations between GitLab and Jenkins, covering application setup, redirect URL configuration, Jenkins backup and proxy adjustments, installing the GitLab hook plugin, generating tokens, and testing connections to ensure successful CI/CD triggering.
This article reviews the weaknesses of cookie‑based single sign‑on, explains the unified authentication center approach, and details the complete CAS (Central Authentication Server) login flow—including first, second, and cross‑domain accesses—illustrated with diagrams.
This article explains the fundamentals of HTTP's stateless nature, session handling, and login state, then introduces the challenges of multi‑system environments and presents a detailed overview of Single Sign‑On (SSO) concepts, flow, deployment, and step‑by‑step Java code examples for both client and server sides.
This article explains the fundamentals of CAS-based Single Sign‑On, detailing the roles of CAS Server and Client, the ticket‑granting process, login and logout flows, session handling, and how global and local sessions interact to provide seamless authentication across multiple web applications.
CAS (Central Authentication Service) is an open‑source, enterprise‑grade single sign‑on solution that centralizes user authentication across trusted systems, offering reduced login time, improved security, and streamlined user management, with a clear protocol flow involving service tickets, redirects, and encrypted cookies.
The article shares Zhihu's multi‑year journey toward service‑oriented architecture, discussing the motivations, practical challenges, design trade‑offs, and lessons learned from microservice, RPC, and SSO‑based vertical splitting, as well as guidelines for defining service boundaries and layering.
This article explains the Central Authentication Service (CAS) as an open‑source enterprise SSO solution, detailing its features, authentication flow, architecture, proxy mode, and security mechanisms that rely on SSL and secure tickets.
This comprehensive article explores the business need for Single Sign-On, explains its internal ticket‑based mechanisms, presents detailed Web‑SSO and desktop SSO implementations with full source code, analyzes security and performance risks, and offers step‑by‑step deployment guidance for Java/J2EE environments.
This article explores various single sign-on strategies—including shared Redis sessions, OpenID-based authentication, cookie-driven OpenID storage, and JSONP cross-domain solutions—detailing their architectures, limitations, and security considerations, and offers practical guidance for building scalable, secure SSO in multi-domain environments.
This article explains the concept of Single Sign-On (SSO), why it’s essential for large web platforms, the core steps of storing and validating trust, common cookie‑based approaches, their security drawbacks, and how server‑side solutions using distributed caches and digital signatures can provide a robust, cross‑domain authentication system.
The article explains why enterprises need a unified Single Sign-On (SSO) system, detailing its benefits for user convenience, administrator workload reduction, security improvements, and integration standards, while comparing cookie‑ and session‑based implementations and illustrating the CAS open‑source solution.
This article explains the concept of Single Sign-On (SSO), why it’s essential for large websites, outlines the core challenges of storing and validating trust, compares client‑side cookie approaches with server‑side solutions, and discusses practical techniques such as encrypted cookies, digital signatures, distributed caches, and whitelist‑based trust management.
This article explains the concepts of Single Sign‑On and Message Queues, outlines their business scenarios, core elements, and simple implementation approaches in J2EE, and provides a concrete Spring‑Redis example with configuration and listener code.