Массовое присваивание и лишние данные в ответах

Jackson в песочнице нет, поэтому разбор JSON здесь ручной, а привязку делает рефлексия: так же, по имени поля, работает любой автоматический биндер.

живой пример

import java.lang.reflect.Field;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.StringJoiner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class MassAssignmentVulnerable {
    static class Customer {
        long id = 42;
        String name = "Ира";
        String role = "user";
        long balance = 0;
        boolean isVerified = false;
        String passwordHash = "$2a$10$Q9xv1eF0";
    }

    static Map<String, String> parseFlatJson(String json) {
        Map<String, String> fields = new LinkedHashMap<>();
        Matcher m = Pattern.compile("\"(\\w+)\"\\s*:\\s*\"?([^\",}]*)\"?").matcher(json);
        while (m.find()) {
            fields.put(m.group(1), m.group(2));
        }
        return fields;
    }

    static void bindAll(Map<String, String> body, Object target) throws Exception {
        for (var entry : body.entrySet()) {
            Field field = target.getClass().getDeclaredField(entry.getKey());
            Class<?> type = field.getType();
            String raw = entry.getValue();
            field.set(target, type == long.class ? Long.parseLong(raw)
                    : type == boolean.class ? Boolean.parseBoolean(raw) : raw);
        }
    }

    static String toJson(Object source) throws Exception {
        StringJoiner json = new StringJoiner(",", "{", "}");
        for (Field field : source.getClass().getDeclaredFields()) {
            json.add("\"" + field.getName() + "\":\"" + field.get(source) + "\"");
        }
        return json.toString();
    }

    public static void main(String[] args) throws Exception {
        String body = "{\"name\":\"Ира К.\",\"role\":\"admin\",\"balance\":100000,\"isVerified\":true}";
        Customer customer = new Customer();
        bindAll(parseFlatJson(body), customer);
        System.out.println("role=" + customer.role + " balance=" + customer.balance
                + " isVerified=" + customer.isVerified);
        System.out.println("ответ: " + toJson(customer));
    }
}

encoding/json раскладывает ключи по полям структуры, а незнакомые ключи по умолчанию молча пропускает. Обратите внимание на "ROLE": документация пакета говорит, что Unmarshal предпочитает точное совпадение имени, но принимает и совпадение без учёта регистра.

живой пример

package main

import (
	"encoding/json"
	"fmt"
)

type Customer struct {
	ID           int64  `json:"id"`
	Name         string `json:"name"`
	Role         string `json:"role"`
	Balance      int64  `json:"balance"`
	IsVerified   bool   `json:"isVerified"`
	PasswordHash string `json:"passwordHash"`
}

func main() {
	customer := Customer{ID: 42, Name: "Ира", Role: "user", PasswordHash: "$2a$10$Q9xv1eF0"}
	body := []byte(`{"name":"Ира К.","ROLE":"admin","balance":100000,"isVerified":true}`)

	if err := json.Unmarshal(body, &customer); err != nil {
		panic(err)
	}
	fmt.Printf("role=%s balance=%d isVerified=%t\n", customer.Role, customer.Balance, customer.IsVerified)

	response, _ := json.Marshal(customer)
	fmt.Println("ответ:", string(response))
}

Object.assign копирует в объект все собственные свойства источника, а JSON.stringify отдаёт все поля, что есть.

живой пример

const customer = {
  id: 42, name: 'Ира', role: 'user', balance: 0, isVerified: false,
  passwordHash: '$2a$10$Q9xv1eF0',
};
const body = '{"name":"Ира К.","role":"admin","balance":100000,"isVerified":true}';

Object.assign(customer, JSON.parse(body));

console.log(`role=${customer.role} balance=${customer.balance} isVerified=${customer.isVerified}`);
console.log('ответ:', JSON.stringify(customer));

Цикл с setattr по ключам тела делает то же, что Model(**data) или model.__dict__.update(data) с ORM-моделью.

живой пример

import json
from dataclasses import asdict, dataclass


@dataclass
class Customer:
    id: int
    name: str
    role: str = "user"
    balance: int = 0
    is_verified: bool = False
    password_hash: str = "$2a$10$Q9xv1eF0"


customer = Customer(id=42, name="Ира")
body = '{"name": "Ира К.", "role": "admin", "balance": 100000, "is_verified": true}'

for key, value in json.loads(body).items():
    setattr(customer, key, value)

print(f"role={customer.role} balance={customer.balance} is_verified={customer.is_verified}")
print("ответ:", json.dumps(asdict(customer), ensure_ascii=False))

Запись UpdateProfileRequest знает свой список полей и отклоняет всё лишнее, ответ собирается в ProfileView.

живой пример

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class MassAssignmentFixed {
    static class Customer {
        long id = 42;
        String name = "Ира";
        String role = "user";
        long balance = 0;
        String passwordHash = "$2a$10$Q9xv1eF0";
    }

    record UpdateProfileRequest(String name) {
        static final Set<String> ALLOWED = Set.of("name");

        static UpdateProfileRequest from(Map<String, String> body) {
            for (String key : body.keySet()) {
                if (!ALLOWED.contains(key)) {
                    throw new IllegalArgumentException("неизвестное поле " + key);
                }
            }
            String name = body.getOrDefault("name", "");
            if (name.isBlank() || name.length() > 100) {
                throw new IllegalArgumentException("name: от 1 до 100 символов");
            }
            return new UpdateProfileRequest(name);
        }
    }

    record ProfileView(long id, String name) {
        static ProfileView of(Customer c) {
            return new ProfileView(c.id, c.name);
        }
    }

    static Map<String, String> parseFlatJson(String json) {
        Map<String, String> fields = new LinkedHashMap<>();
        Matcher m = Pattern.compile("\"(\\w+)\"\\s*:\\s*\"?([^\",}]*)\"?").matcher(json);
        while (m.find()) {
            fields.put(m.group(1), m.group(2));
        }
        return fields;
    }

    public static void main(String[] args) {
        Customer customer = new Customer();
        for (String body : new String[]{
                "{\"name\":\"Ира К.\",\"role\":\"admin\",\"balance\":100000}",
                "{\"name\":\"Ира К.\"}"}) {
            try {
                UpdateProfileRequest request = UpdateProfileRequest.from(parseFlatJson(body));
                customer.name = request.name();
                System.out.println("200 " + ProfileView.of(customer));
            } catch (IllegalArgumentException e) {
                System.out.println("400 " + e.getMessage());
            }
        }
        System.out.println("role=" + customer.role + " balance=" + customer.balance);
    }
}

Decoder.DisallowUnknownFields по документации возвращает ошибку, если в объекте есть ключ, которому нет экспортированного поля в структуре назначения.

живой пример

package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"unicode/utf8"
)

type Customer struct {
	ID           int64
	Name         string
	Role         string
	Balance      int64
	PasswordHash string
}

type UpdateProfileRequest struct {
	Name string `json:"name"`
}

type ProfileView struct {
	ID   int64  `json:"id"`
	Name string `json:"name"`
}

func decodeUpdate(body []byte) (UpdateProfileRequest, error) {
	var req UpdateProfileRequest
	dec := json.NewDecoder(bytes.NewReader(body))
	dec.DisallowUnknownFields()
	if err := dec.Decode(&req); err != nil {
		return req, err
	}
	if n := utf8.RuneCountInString(req.Name); n < 1 || n > 100 {
		return req, errors.New("name: от 1 до 100 символов")
	}
	return req, nil
}

func main() {
	customer := Customer{ID: 42, Name: "Ира", Role: "user", PasswordHash: "$2a$10$Q9xv1eF0"}
	for _, body := range []string{
		`{"name":"Ира К.","role":"admin","balance":100000}`,
		`{"name":"Ира К."}`,
	} {
		req, err := decodeUpdate([]byte(body))
		if err != nil {
			fmt.Println("400", err)
			continue
		}
		customer.Name = req.Name
		view, _ := json.Marshal(ProfileView{ID: customer.ID, Name: customer.Name})
		fmt.Println("200", string(view))
	}
	fmt.Printf("role=%s balance=%d\n", customer.Role, customer.Balance)
}

Разрешённые ключи перечислены явно, тип и длина проверены до того, как значение тронет объект.

живой пример

const customer = { id: 42, name: 'Ира', role: 'user', balance: 0, passwordHash: '$2a$10$Q9xv1eF0' };
const ALLOWED = new Set(['name']);

function parseUpdateProfile(raw) {
  const body = JSON.parse(raw);
  const unknown = Object.keys(body).filter((key) => !ALLOWED.has(key));
  if (unknown.length > 0) throw new Error(`неизвестные поля: ${unknown.join(', ')}`);
  const { name } = body;
  if (typeof name !== 'string' || name.length < 1 || name.length > 100) {
    throw new Error('name: строка от 1 до 100 символов');
  }
  return { name };
}

const toProfileView = (c) => ({ id: c.id, name: c.name });

for (const raw of ['{"name":"Ира К.","role":"admin","balance":100000}', '{"name":"Ира К."}']) {
  try {
    const update = parseUpdateProfile(raw);
    customer.name = update.name;
    console.log('200', JSON.stringify(toProfileView(customer)));
  } catch (e) {
    console.log('400', e.message);
  }
}
console.log(`role=${customer.role} balance=${customer.balance}`);

Разрешённые ключи берутся из полей dataclass запроса; лишний ключ отклоняется своим текстом, а не сообщением исключения Python, которое наружу не отдают.

живой пример

import json
from dataclasses import asdict, dataclass, fields


@dataclass
class Customer:
    id: int
    name: str
    role: str = "user"
    balance: int = 0
    password_hash: str = "$2a$10$Q9xv1eF0"


@dataclass(frozen=True)
class UpdateProfileRequest:
    name: str

    def __post_init__(self):
        if not isinstance(self.name, str) or not 1 <= len(self.name) <= 100:
            raise ValueError("name: строка от 1 до 100 символов")


@dataclass(frozen=True)
class ProfileView:
    id: int
    name: str


def parse_update(raw: str) -> UpdateProfileRequest:
    body = json.loads(raw)
    allowed = {f.name for f in fields(UpdateProfileRequest)}
    unknown = [key for key in body if key not in allowed]
    if unknown:
        raise ValueError(f"неизвестные поля: {', '.join(unknown)}")
    return UpdateProfileRequest(**body)


customer = Customer(id=42, name="Ира")
for raw in ['{"name": "Ира К.", "role": "admin", "balance": 100000}', '{"name": "Ира К."}']:
    try:
        update = parse_update(raw)
    except ValueError as e:
        print("400", e)
        continue
    customer.name = update.name
    print("200", json.dumps(asdict(ProfileView(customer.id, customer.name)), ensure_ascii=False))

print(f"role={customer.role} balance={customer.balance}")

Записи как DTO, Bean Validation на размеры, явное переложение в сущность. ignoreUnknown = true в @JsonIgnoreProperties означает лишь «незнакомые свойства можно пропустить» и от mass assignment не защищает: role в сущности знакомое поле и привяжется. Если сущность всё же приходится отдавать или принимать, поле закрывают @JsonIgnore или @JsonProperty(access = READ_ONLY): такое свойство читается при сериализации, но не записывается при десериализации.

public record UpdateProfileRequest(
        @NotBlank @Size(max = 100) String name,
        @Pattern(regexp = "\\+7\\d{10}") String phone) {
}

public record ProfileView(long id, String name, String phone) {
    static ProfileView of(Customer c) {
        return new ProfileView(c.getId(), c.getName(), c.getPhone());
    }
}

@RestController
@RequestMapping("/api/me")
class ProfileController {
    private final CustomerRepository customers;

    ProfileController(CustomerRepository customers) {
        this.customers = customers;
    }

    @PatchMapping
    ProfileView update(@AuthenticationPrincipal Jwt jwt, @Valid @RequestBody UpdateProfileRequest request) {
        Customer customer = customers.findById(Long.parseLong(jwt.getSubject())).orElseThrow();
        customer.rename(request.name());
        customer.changePhone(request.phone());
        return ProfileView.of(customers.save(customer));
    }
}

@Entity
class Customer {
    @Id private Long id;
    private String name;
    private String phone;
    @JsonProperty(access = JsonProperty.Access.READ_ONLY) private String role;
    @JsonIgnore private String passwordHash;
}

Отклонять лишние ключи, а не пропускать, включают настройкой spring.jackson.deserialization.fail-on-unknown-properties=true.

Отдельные структуры на вход и выход, DisallowUnknownFields и предел размера тела через http.MaxBytesReader. Тег json:"-" на чувствительных полях сущности оставляют вторым рубежом.

type Customer struct {
	ID           int64
	Name         string
	Phone        string
	Role         string `json:"-"`
	PasswordHash string `json:"-"`
}

func (h *ProfileHandler) Update(w http.ResponseWriter, r *http.Request) {
	r.Body = http.MaxBytesReader(w, r.Body, 64<<10)
	dec := json.NewDecoder(r.Body)
	dec.DisallowUnknownFields()

	var req UpdateProfileRequest
	if err := dec.Decode(&req); err != nil {
		http.Error(w, "некорректное тело запроса", http.StatusBadRequest)
		return
	}
	if err := req.Validate(); err != nil {
		http.Error(w, err.Error(), http.StatusUnprocessableEntity)
		return
	}

	customer, err := h.customers.UpdateProfile(r.Context(), auth.CustomerID(r.Context()), req.Name, req.Phone)
	if err != nil {
		http.Error(w, "internal error", http.StatusInternalServerError)
		return
	}
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(ProfileView{ID: customer.ID, Name: customer.Name, Phone: customer.Phone})
}

В NestJS глобальный ValidationPipe с whitelist: true выбрасывает свойства без декораторов валидации, а forbidNonWhitelisted: true вместо этого отвечает ошибкой. Ответ собирается явно; если отдаёте класс сущности, поле закрывают @Exclude() из class-transformer вместе с ClassSerializerInterceptor.

export class UpdateProfileDto {
  @IsString()
  @Length(1, 100)
  name: string;

  @IsOptional()
  @Matches(/^\+7\d{10}$/)
  phone?: string;
}

app.useGlobalPipes(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true }));

@Controller('api/me')
export class ProfileController {
  constructor(private readonly customers: CustomersService) {}

  @Patch()
  async update(@Req() req: AuthRequest, @Body() dto: UpdateProfileDto): Promise<ProfileView> {
    const customer = await this.customers.updateProfile(req.user.id, { name: dto.name, phone: dto.phone });
    return { id: customer.id, name: customer.name, phone: customer.phone };
  }
}

В Pydantic extra по умолчанию 'ignore', а extra='forbid' даёт ValidationError на любое лишнее поле, и FastAPI отвечает 422. response_model ограничивает и фильтрует ответ до объявленных полей, даже если обработчик вернул ORM-объект целиком.

class UpdateProfileIn(BaseModel):
    model_config = ConfigDict(extra="forbid")

    name: str = Field(min_length=1, max_length=100)
    phone: str | None = Field(default=None, pattern=r"^\+7\d{10}$")


class ProfileOut(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    id: int
    name: str
    phone: str | None


@router.patch("/api/me", response_model=ProfileOut)
async def update_profile(
    body: UpdateProfileIn,
    user: CurrentUser,
    session: AsyncSession = Depends(get_session),
):
    customer = await session.get(Customer, user.id)
    customer.name = body.name
    customer.phone = body.phone
    await session.commit()
    return customer