diff --git a/db/ent/migrate/schema.go b/db/ent/migrate/schema.go
index 3a9116d..03a1c52 100644
--- a/db/ent/migrate/schema.go
+++ b/db/ent/migrate/schema.go
@@ -107,6 +107,7 @@ var (
 	UserTokensColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeInt, Increment: true},
 		{Name: "token_id", Type: field.TypeUint64},
+		{Name: "uuid", Type: field.TypeString},
 	}
 	// UserTokensTable holds the schema information for the "user_tokens" table.
 	UserTokensTable = &schema.Table{
diff --git a/db/ent/mutation.go b/db/ent/mutation.go
index 325ff80..31cbcfd 100644
--- a/db/ent/mutation.go
+++ b/db/ent/mutation.go
@@ -1905,6 +1905,7 @@ type UserTokenMutation struct {
 	id            *int
 	token_id      *uint64
 	addtoken_id   *int64
+	uuid          *string
 	clearedFields map[string]struct{}
 	done          bool
 	oldValue      func(context.Context) (*UserToken, error)
@@ -2065,6 +2066,42 @@ func (m *UserTokenMutation) ResetTokenID() {
 	m.addtoken_id = nil
 }
 
+// SetUUID sets the "uuid" field.
+func (m *UserTokenMutation) SetUUID(s string) {
+	m.uuid = &s
+}
+
+// UUID returns the value of the "uuid" field in the mutation.
+func (m *UserTokenMutation) UUID() (r string, exists bool) {
+	v := m.uuid
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldUUID returns the old "uuid" field's value of the UserToken entity.
+// If the UserToken object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *UserTokenMutation) OldUUID(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldUUID is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldUUID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldUUID: %w", err)
+	}
+	return oldValue.UUID, nil
+}
+
+// ResetUUID resets all changes to the "uuid" field.
+func (m *UserTokenMutation) ResetUUID() {
+	m.uuid = nil
+}
+
 // Where appends a list predicates to the UserTokenMutation builder.
 func (m *UserTokenMutation) Where(ps ...predicate.UserToken) {
 	m.predicates = append(m.predicates, ps...)
@@ -2099,10 +2136,13 @@ func (m *UserTokenMutation) Type() string {
 // order to get all numeric fields that were incremented/decremented, call
 // AddedFields().
 func (m *UserTokenMutation) Fields() []string {
-	fields := make([]string, 0, 1)
+	fields := make([]string, 0, 2)
 	if m.token_id != nil {
 		fields = append(fields, usertoken.FieldTokenID)
 	}
+	if m.uuid != nil {
+		fields = append(fields, usertoken.FieldUUID)
+	}
 	return fields
 }
 
@@ -2113,6 +2153,8 @@ func (m *UserTokenMutation) Field(name string) (ent.Value, bool) {
 	switch name {
 	case usertoken.FieldTokenID:
 		return m.TokenID()
+	case usertoken.FieldUUID:
+		return m.UUID()
 	}
 	return nil, false
 }
@@ -2124,6 +2166,8 @@ func (m *UserTokenMutation) OldField(ctx context.Context, name string) (ent.Valu
 	switch name {
 	case usertoken.FieldTokenID:
 		return m.OldTokenID(ctx)
+	case usertoken.FieldUUID:
+		return m.OldUUID(ctx)
 	}
 	return nil, fmt.Errorf("unknown UserToken field %s", name)
 }
@@ -2140,6 +2184,13 @@ func (m *UserTokenMutation) SetField(name string, value ent.Value) error {
 		}
 		m.SetTokenID(v)
 		return nil
+	case usertoken.FieldUUID:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetUUID(v)
+		return nil
 	}
 	return fmt.Errorf("unknown UserToken field %s", name)
 }
@@ -2207,6 +2258,9 @@ func (m *UserTokenMutation) ResetField(name string) error {
 	case usertoken.FieldTokenID:
 		m.ResetTokenID()
 		return nil
+	case usertoken.FieldUUID:
+		m.ResetUUID()
+		return nil
 	}
 	return fmt.Errorf("unknown UserToken field %s", name)
 }
diff --git a/db/ent/schema/usertoken.go b/db/ent/schema/usertoken.go
index a9d844c..6b56f71 100644
--- a/db/ent/schema/usertoken.go
+++ b/db/ent/schema/usertoken.go
@@ -15,6 +15,7 @@ func (UserToken) Fields() []ent.Field {
 	return []ent.Field{
 		// 用于验证 jwt token 是否被注销，若相同则有效
 		field.Uint64("token_id"),
+		field.String("uuid"),
 	}
 }
 
diff --git a/db/ent/usertoken.go b/db/ent/usertoken.go
index 66b5b3b..41da04b 100644
--- a/db/ent/usertoken.go
+++ b/db/ent/usertoken.go
@@ -17,7 +17,9 @@ type UserToken struct {
 	// ID of the ent.
 	ID int `json:"id,omitempty"`
 	// TokenID holds the value of the "token_id" field.
-	TokenID      uint64 `json:"token_id,omitempty"`
+	TokenID uint64 `json:"token_id,omitempty"`
+	// UUID holds the value of the "uuid" field.
+	UUID         string `json:"uuid,omitempty"`
 	selectValues sql.SelectValues
 }
 
@@ -28,6 +30,8 @@ func (*UserToken) scanValues(columns []string) ([]any, error) {
 		switch columns[i] {
 		case usertoken.FieldID, usertoken.FieldTokenID:
 			values[i] = new(sql.NullInt64)
+		case usertoken.FieldUUID:
+			values[i] = new(sql.NullString)
 		default:
 			values[i] = new(sql.UnknownType)
 		}
@@ -55,6 +59,12 @@ func (ut *UserToken) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				ut.TokenID = uint64(value.Int64)
 			}
+		case usertoken.FieldUUID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field uuid", values[i])
+			} else if value.Valid {
+				ut.UUID = value.String
+			}
 		default:
 			ut.selectValues.Set(columns[i], values[i])
 		}
@@ -93,6 +103,9 @@ func (ut *UserToken) String() string {
 	builder.WriteString(fmt.Sprintf("id=%v, ", ut.ID))
 	builder.WriteString("token_id=")
 	builder.WriteString(fmt.Sprintf("%v", ut.TokenID))
+	builder.WriteString(", ")
+	builder.WriteString("uuid=")
+	builder.WriteString(ut.UUID)
 	builder.WriteByte(')')
 	return builder.String()
 }
diff --git a/db/ent/usertoken/usertoken.go b/db/ent/usertoken/usertoken.go
index c184889..2e001d7 100644
--- a/db/ent/usertoken/usertoken.go
+++ b/db/ent/usertoken/usertoken.go
@@ -13,6 +13,8 @@ const (
 	FieldID = "id"
 	// FieldTokenID holds the string denoting the token_id field in the database.
 	FieldTokenID = "token_id"
+	// FieldUUID holds the string denoting the uuid field in the database.
+	FieldUUID = "uuid"
 	// Table holds the table name of the usertoken in the database.
 	Table = "user_tokens"
 )
@@ -21,6 +23,7 @@ const (
 var Columns = []string{
 	FieldID,
 	FieldTokenID,
+	FieldUUID,
 }
 
 // ValidColumn reports if the column name is valid (part of the table columns).
@@ -45,3 +48,8 @@ func ByID(opts ...sql.OrderTermOption) OrderOption {
 func ByTokenID(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldTokenID, opts...).ToFunc()
 }
+
+// ByUUID orders the results by the uuid field.
+func ByUUID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUUID, opts...).ToFunc()
+}
diff --git a/db/ent/usertoken/where.go b/db/ent/usertoken/where.go
index 3d08b83..491cd20 100644
--- a/db/ent/usertoken/where.go
+++ b/db/ent/usertoken/where.go
@@ -57,6 +57,11 @@ func TokenID(v uint64) predicate.UserToken {
 	return predicate.UserToken(sql.FieldEQ(FieldTokenID, v))
 }
 
+// UUID applies equality check predicate on the "uuid" field. It's identical to UUIDEQ.
+func UUID(v string) predicate.UserToken {
+	return predicate.UserToken(sql.FieldEQ(FieldUUID, v))
+}
+
 // TokenIDEQ applies the EQ predicate on the "token_id" field.
 func TokenIDEQ(v uint64) predicate.UserToken {
 	return predicate.UserToken(sql.FieldEQ(FieldTokenID, v))
@@ -97,6 +102,71 @@ func TokenIDLTE(v uint64) predicate.UserToken {
 	return predicate.UserToken(sql.FieldLTE(FieldTokenID, v))
 }
 
+// UUIDEQ applies the EQ predicate on the "uuid" field.
+func UUIDEQ(v string) predicate.UserToken {
+	return predicate.UserToken(sql.FieldEQ(FieldUUID, v))
+}
+
+// UUIDNEQ applies the NEQ predicate on the "uuid" field.
+func UUIDNEQ(v string) predicate.UserToken {
+	return predicate.UserToken(sql.FieldNEQ(FieldUUID, v))
+}
+
+// UUIDIn applies the In predicate on the "uuid" field.
+func UUIDIn(vs ...string) predicate.UserToken {
+	return predicate.UserToken(sql.FieldIn(FieldUUID, vs...))
+}
+
+// UUIDNotIn applies the NotIn predicate on the "uuid" field.
+func UUIDNotIn(vs ...string) predicate.UserToken {
+	return predicate.UserToken(sql.FieldNotIn(FieldUUID, vs...))
+}
+
+// UUIDGT applies the GT predicate on the "uuid" field.
+func UUIDGT(v string) predicate.UserToken {
+	return predicate.UserToken(sql.FieldGT(FieldUUID, v))
+}
+
+// UUIDGTE applies the GTE predicate on the "uuid" field.
+func UUIDGTE(v string) predicate.UserToken {
+	return predicate.UserToken(sql.FieldGTE(FieldUUID, v))
+}
+
+// UUIDLT applies the LT predicate on the "uuid" field.
+func UUIDLT(v string) predicate.UserToken {
+	return predicate.UserToken(sql.FieldLT(FieldUUID, v))
+}
+
+// UUIDLTE applies the LTE predicate on the "uuid" field.
+func UUIDLTE(v string) predicate.UserToken {
+	return predicate.UserToken(sql.FieldLTE(FieldUUID, v))
+}
+
+// UUIDContains applies the Contains predicate on the "uuid" field.
+func UUIDContains(v string) predicate.UserToken {
+	return predicate.UserToken(sql.FieldContains(FieldUUID, v))
+}
+
+// UUIDHasPrefix applies the HasPrefix predicate on the "uuid" field.
+func UUIDHasPrefix(v string) predicate.UserToken {
+	return predicate.UserToken(sql.FieldHasPrefix(FieldUUID, v))
+}
+
+// UUIDHasSuffix applies the HasSuffix predicate on the "uuid" field.
+func UUIDHasSuffix(v string) predicate.UserToken {
+	return predicate.UserToken(sql.FieldHasSuffix(FieldUUID, v))
+}
+
+// UUIDEqualFold applies the EqualFold predicate on the "uuid" field.
+func UUIDEqualFold(v string) predicate.UserToken {
+	return predicate.UserToken(sql.FieldEqualFold(FieldUUID, v))
+}
+
+// UUIDContainsFold applies the ContainsFold predicate on the "uuid" field.
+func UUIDContainsFold(v string) predicate.UserToken {
+	return predicate.UserToken(sql.FieldContainsFold(FieldUUID, v))
+}
+
 // And groups predicates with the AND operator between them.
 func And(predicates ...predicate.UserToken) predicate.UserToken {
 	return predicate.UserToken(func(s *sql.Selector) {
diff --git a/db/ent/usertoken_create.go b/db/ent/usertoken_create.go
index bd62a2c..fb296b0 100644
--- a/db/ent/usertoken_create.go
+++ b/db/ent/usertoken_create.go
@@ -25,6 +25,12 @@ func (utc *UserTokenCreate) SetTokenID(u uint64) *UserTokenCreate {
 	return utc
 }
 
+// SetUUID sets the "uuid" field.
+func (utc *UserTokenCreate) SetUUID(s string) *UserTokenCreate {
+	utc.mutation.SetUUID(s)
+	return utc
+}
+
 // Mutation returns the UserTokenMutation object of the builder.
 func (utc *UserTokenCreate) Mutation() *UserTokenMutation {
 	return utc.mutation
@@ -62,6 +68,9 @@ func (utc *UserTokenCreate) check() error {
 	if _, ok := utc.mutation.TokenID(); !ok {
 		return &ValidationError{Name: "token_id", err: errors.New(`ent: missing required field "UserToken.token_id"`)}
 	}
+	if _, ok := utc.mutation.UUID(); !ok {
+		return &ValidationError{Name: "uuid", err: errors.New(`ent: missing required field "UserToken.uuid"`)}
+	}
 	return nil
 }
 
@@ -92,6 +101,10 @@ func (utc *UserTokenCreate) createSpec() (*UserToken, *sqlgraph.CreateSpec) {
 		_spec.SetField(usertoken.FieldTokenID, field.TypeUint64, value)
 		_node.TokenID = value
 	}
+	if value, ok := utc.mutation.UUID(); ok {
+		_spec.SetField(usertoken.FieldUUID, field.TypeString, value)
+		_node.UUID = value
+	}
 	return _node, _spec
 }
 
diff --git a/db/ent/usertoken_update.go b/db/ent/usertoken_update.go
index 0cedf04..6653b54 100644
--- a/db/ent/usertoken_update.go
+++ b/db/ent/usertoken_update.go
@@ -40,6 +40,12 @@ func (utu *UserTokenUpdate) AddTokenID(u int64) *UserTokenUpdate {
 	return utu
 }
 
+// SetUUID sets the "uuid" field.
+func (utu *UserTokenUpdate) SetUUID(s string) *UserTokenUpdate {
+	utu.mutation.SetUUID(s)
+	return utu
+}
+
 // Mutation returns the UserTokenMutation object of the builder.
 func (utu *UserTokenUpdate) Mutation() *UserTokenMutation {
 	return utu.mutation
@@ -87,6 +93,9 @@ func (utu *UserTokenUpdate) sqlSave(ctx context.Context) (n int, err error) {
 	if value, ok := utu.mutation.AddedTokenID(); ok {
 		_spec.AddField(usertoken.FieldTokenID, field.TypeUint64, value)
 	}
+	if value, ok := utu.mutation.UUID(); ok {
+		_spec.SetField(usertoken.FieldUUID, field.TypeString, value)
+	}
 	if n, err = sqlgraph.UpdateNodes(ctx, utu.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{usertoken.Label}
@@ -120,6 +129,12 @@ func (utuo *UserTokenUpdateOne) AddTokenID(u int64) *UserTokenUpdateOne {
 	return utuo
 }
 
+// SetUUID sets the "uuid" field.
+func (utuo *UserTokenUpdateOne) SetUUID(s string) *UserTokenUpdateOne {
+	utuo.mutation.SetUUID(s)
+	return utuo
+}
+
 // Mutation returns the UserTokenMutation object of the builder.
 func (utuo *UserTokenUpdateOne) Mutation() *UserTokenMutation {
 	return utuo.mutation
@@ -197,6 +212,9 @@ func (utuo *UserTokenUpdateOne) sqlSave(ctx context.Context) (_node *UserToken,
 	if value, ok := utuo.mutation.AddedTokenID(); ok {
 		_spec.AddField(usertoken.FieldTokenID, field.TypeUint64, value)
 	}
+	if value, ok := utuo.mutation.UUID(); ok {
+		_spec.SetField(usertoken.FieldUUID, field.TypeString, value)
+	}
 	_node = &UserToken{config: utuo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues
diff --git a/handle/yggdrasil/validate.go b/handle/yggdrasil/validate.go
new file mode 100644
index 0000000..8c1257b
--- /dev/null
+++ b/handle/yggdrasil/validate.go
@@ -0,0 +1,13 @@
+package yggdrasil
+
+import (
+	"net/http"
+
+	"github.com/julienschmidt/httprouter"
+)
+
+func (y *Yggdrasil) Validate() httprouter.Handle {
+	return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
+
+	}
+}