forked from baron/baron-sso
332 lines
10 KiB
Go
332 lines
10 KiB
Go
package service
|
|
|
|
import (
|
|
"baron-sso-backend/internal/domain"
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"log/slog"
|
|
"net"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"time"
|
|
)
|
|
|
|
// OryProvider는 Kratos/Hydra를 기반으로 하는 IDP 어댑터의 최소 스켈레톤입니다.
|
|
// 지금은 스키마 메타데이터만 반환하며, 나머지 동작은 후속 작업에서 구현합니다.
|
|
type OryProvider struct {
|
|
KratosAdminURL string
|
|
KratosPublicURL string
|
|
HydraAdminURL string
|
|
HTTPClient *http.Client
|
|
}
|
|
|
|
func NewOryProvider() *OryProvider {
|
|
return &OryProvider{
|
|
KratosAdminURL: getenv("KRATOS_ADMIN_URL", "http://kratos:4434"),
|
|
KratosPublicURL: getenv("KRATOS_PUBLIC_URL", "http://kratos:4433"),
|
|
HydraAdminURL: getenv("HYDRA_ADMIN_URL", "http://hydra:4445"),
|
|
}
|
|
}
|
|
|
|
func (o *OryProvider) Name() string {
|
|
return "Ory (Kratos/Hydra)"
|
|
}
|
|
|
|
// GetMetadata는 BrokerUser가 요구하는 필드를 Kratos traits에 매핑 가능하다는 가정으로 반환합니다.
|
|
func (o *OryProvider) GetMetadata() (*domain.IDPMetadata, error) {
|
|
return &domain.IDPMetadata{
|
|
SupportedFields: []string{
|
|
"id", "email", "name", "phone_number",
|
|
"grade", "department", "affiliationType", "companyCode",
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
// CreateUser는 Kratos Admin API를 통해 identity를 생성합니다.
|
|
func (o *OryProvider) CreateUser(user *domain.BrokerUser, password string) (string, error) {
|
|
if user == nil {
|
|
return "", fmt.Errorf("ory provider: user payload is nil")
|
|
}
|
|
if user.Email == "" || password == "" {
|
|
return "", fmt.Errorf("ory provider: email and password are required")
|
|
}
|
|
|
|
// 중복 확인
|
|
existingID, err := o.findIdentityID(user.Email)
|
|
if err != nil {
|
|
return "", fmt.Errorf("ory provider: search identity failed: %w", err)
|
|
}
|
|
if existingID != "" {
|
|
return "", fmt.Errorf("ory provider: identity already exists for email=%s", user.Email)
|
|
}
|
|
|
|
traits := map[string]interface{}{
|
|
"email": user.Email,
|
|
"name": user.Name,
|
|
"phone_number": user.PhoneNumber,
|
|
}
|
|
for k, v := range user.Attributes {
|
|
traits[k] = v
|
|
}
|
|
|
|
payload := map[string]interface{}{
|
|
"schema_id": "default",
|
|
"traits": traits,
|
|
"credentials": map[string]interface{}{
|
|
"password": map[string]interface{}{
|
|
"config": map[string]string{
|
|
"password": password,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
body, _ := json.Marshal(payload)
|
|
req, err := http.NewRequestWithContext(context.Background(), http.MethodPost, fmt.Sprintf("%s/admin/identities", o.KratosAdminURL), bytes.NewReader(body))
|
|
if err != nil {
|
|
return "", fmt.Errorf("ory provider: build create request failed: %w", err)
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
resp, err := o.httpClient().Do(req)
|
|
if err != nil {
|
|
return "", fmt.Errorf("ory provider: create identity request failed: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode >= 300 {
|
|
respBody, _ := io.ReadAll(io.LimitReader(resp.Body, 2048))
|
|
return "", fmt.Errorf("ory provider: create identity failed status=%d body=%s", resp.StatusCode, string(respBody))
|
|
}
|
|
|
|
var created struct {
|
|
ID string `json:"id"`
|
|
}
|
|
if err := json.NewDecoder(resp.Body).Decode(&created); err != nil {
|
|
return "", fmt.Errorf("ory provider: decode create identity response failed: %w", err)
|
|
}
|
|
|
|
slog.Info("Ory identity created", "identity_id", created.ID, "email", user.Email)
|
|
return created.ID, nil
|
|
}
|
|
|
|
// SignIn은 Kratos Public API의 login API 플로우를 사용해 세션 토큰을 발급합니다.
|
|
func (o *OryProvider) SignIn(loginID, password string) (*domain.AuthInfo, error) {
|
|
if loginID == "" || password == "" {
|
|
return nil, fmt.Errorf("ory provider: loginID and password are required")
|
|
}
|
|
|
|
flowID, err := o.startLoginFlow()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
body, _ := json.Marshal(map[string]string{
|
|
"identifier": loginID,
|
|
"password": password,
|
|
"method": "password",
|
|
})
|
|
loginURL := fmt.Sprintf("%s/self-service/login?flow=%s", o.KratosPublicURL, flowID)
|
|
req, err := http.NewRequestWithContext(context.Background(), http.MethodPost, loginURL, bytes.NewReader(body))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("ory provider: build login request failed: %w", err)
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
resp, err := o.httpClient().Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("ory provider: login request failed: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode >= 300 {
|
|
respBody, _ := io.ReadAll(io.LimitReader(resp.Body, 2048))
|
|
return nil, fmt.Errorf("ory provider: login failed status=%d body=%s", resp.StatusCode, string(respBody))
|
|
}
|
|
|
|
var result struct {
|
|
SessionToken string `json:"session_token"`
|
|
SessionTokenExpiresAt time.Time `json:"session_token_expires_at"`
|
|
Session struct {
|
|
Identity struct {
|
|
ID string `json:"id"`
|
|
} `json:"identity"`
|
|
} `json:"session"`
|
|
}
|
|
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
|
|
return nil, fmt.Errorf("ory provider: decode login response failed: %w", err)
|
|
}
|
|
if result.SessionToken == "" {
|
|
return nil, fmt.Errorf("ory provider: empty session token returned")
|
|
}
|
|
|
|
slog.Info("Ory login successful",
|
|
"identity_id", result.Session.Identity.ID,
|
|
"loginID", loginID,
|
|
"expires_at", result.SessionTokenExpiresAt,
|
|
)
|
|
|
|
return &domain.AuthInfo{
|
|
SessionToken: &domain.Token{
|
|
JWT: result.SessionToken,
|
|
Expiration: result.SessionTokenExpiresAt,
|
|
},
|
|
Subject: result.Session.Identity.ID,
|
|
}, nil
|
|
}
|
|
|
|
// InitiatePasswordReset는 현재 내부 토큰/메일 흐름을 사용하고 있으므로 NO-OP로 둡니다.
|
|
func (o *OryProvider) InitiatePasswordReset(loginID, redirectUrl string) error {
|
|
slog.Info("Ory InitiatePasswordReset bypassed (handled by app internal flow)", "loginID", loginID, "redirect", redirectUrl)
|
|
return nil
|
|
}
|
|
|
|
// VerifyPasswordResetToken는 내부 토큰 검증 흐름을 사용하므로 아직 구현하지 않습니다.
|
|
func (o *OryProvider) VerifyPasswordResetToken(token string) (*domain.AuthInfo, error) {
|
|
return nil, fmt.Errorf("ory provider: VerifyPasswordResetToken not implemented (internal token flow expected)")
|
|
}
|
|
|
|
// UpdateUserPassword: Kratos Admin API를 통해 비밀번호를 갱신합니다.
|
|
func (o *OryProvider) UpdateUserPassword(loginID, newPassword string, r *http.Request) error {
|
|
if loginID == "" || newPassword == "" {
|
|
return fmt.Errorf("ory provider: loginID or new password missing")
|
|
}
|
|
|
|
identityID, err := o.findIdentityID(loginID)
|
|
if err != nil {
|
|
return fmt.Errorf("ory provider: find identity failed: %w", err)
|
|
}
|
|
|
|
if identityID == "" {
|
|
return fmt.Errorf("ory provider: identity not found for loginID=%s", loginID)
|
|
}
|
|
|
|
payload := map[string]interface{}{
|
|
"credentials": map[string]interface{}{
|
|
"password": map[string]interface{}{
|
|
"config": map[string]string{
|
|
"password": newPassword,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
body, _ := json.Marshal(payload)
|
|
req, err := http.NewRequestWithContext(context.Background(), http.MethodPatch, fmt.Sprintf("%s/admin/identities/%s", o.KratosAdminURL, identityID), bytes.NewReader(body))
|
|
if err != nil {
|
|
return fmt.Errorf("ory provider: build request failed: %w", err)
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
resp, err := o.httpClient().Do(req)
|
|
if err != nil {
|
|
return fmt.Errorf("ory provider: request failed: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode >= 300 {
|
|
respBody, _ := io.ReadAll(io.LimitReader(resp.Body, 1024))
|
|
return fmt.Errorf("ory provider: password update failed status=%d body=%s", resp.StatusCode, string(respBody))
|
|
}
|
|
|
|
slog.Info("Ory password updated via Kratos admin", "identity_id", identityID, "loginID", loginID)
|
|
return nil
|
|
}
|
|
|
|
func getenv(key, fallback string) string {
|
|
if v := os.Getenv(key); v != "" {
|
|
return v
|
|
}
|
|
return fallback
|
|
}
|
|
|
|
// findIdentityID: Kratos Admin API에서 credentials_identifier로 검색 후 첫 번째 identity id 반환
|
|
func (o *OryProvider) findIdentityID(loginID string) (string, error) {
|
|
u, err := url.Parse(fmt.Sprintf("%s/admin/identities", o.KratosAdminURL))
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
query := u.Query()
|
|
query.Set("credentials_identifier", loginID)
|
|
u.RawQuery = query.Encode()
|
|
|
|
req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, u.String(), nil)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
resp, err := o.httpClient().Do(req)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode == http.StatusNotFound {
|
|
return "", nil
|
|
}
|
|
if resp.StatusCode >= 300 {
|
|
body, _ := io.ReadAll(io.LimitReader(resp.Body, 1024))
|
|
return "", fmt.Errorf("kratos admin search failed status=%d body=%s", resp.StatusCode, string(body))
|
|
}
|
|
|
|
var identities []struct {
|
|
ID string `json:"id"`
|
|
}
|
|
if err := json.NewDecoder(resp.Body).Decode(&identities); err != nil {
|
|
return "", fmt.Errorf("decode response failed: %w", err)
|
|
}
|
|
if len(identities) == 0 {
|
|
return "", nil
|
|
}
|
|
return identities[0].ID, nil
|
|
}
|
|
|
|
func (o *OryProvider) httpClient() *http.Client {
|
|
if o.HTTPClient != nil {
|
|
return o.HTTPClient
|
|
}
|
|
return &http.Client{
|
|
Timeout: 10 * time.Second,
|
|
Transport: &http.Transport{
|
|
DialContext: (&net.Dialer{
|
|
Timeout: 5 * time.Second,
|
|
KeepAlive: 30 * time.Second,
|
|
}).DialContext,
|
|
TLSHandshakeTimeout: 5 * time.Second,
|
|
},
|
|
}
|
|
}
|
|
|
|
// startLoginFlow는 Kratos Public API에서 login flow ID를 발급받습니다.
|
|
func (o *OryProvider) startLoginFlow() (string, error) {
|
|
req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, fmt.Sprintf("%s/self-service/login/api", o.KratosPublicURL), nil)
|
|
if err != nil {
|
|
return "", fmt.Errorf("ory provider: build login flow request failed: %w", err)
|
|
}
|
|
|
|
resp, err := o.httpClient().Do(req)
|
|
if err != nil {
|
|
return "", fmt.Errorf("ory provider: login flow request failed: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode >= 300 {
|
|
body, _ := io.ReadAll(io.LimitReader(resp.Body, 2048))
|
|
return "", fmt.Errorf("ory provider: login flow failed status=%d body=%s", resp.StatusCode, string(body))
|
|
}
|
|
|
|
var result struct {
|
|
ID string `json:"id"`
|
|
}
|
|
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
|
|
return "", fmt.Errorf("ory provider: decode login flow failed: %w", err)
|
|
}
|
|
if result.ID == "" {
|
|
return "", fmt.Errorf("ory provider: empty login flow id")
|
|
}
|
|
return result.ID, nil
|
|
}
|