### Is there an existing issue for this?

- [X] I have searched the existing issues

### Current Behavior

Localstack KMS allows plaintext data larger than the maximum size allowed by the key specs to be encrypted, which is different from AWS KMS. This results in inconsistent behavior between Localstack and AWS.

### Expected Behavior

The KMS feature in Localstack should check the size of plaintext based on the key specs to encrypt, just like AWS KMS. This ensures that the encrypted data is consistent between Localstack and AWS.

### How are you starting LocalStack?

With a docker-compose file

### Steps To Reproduce

```yaml
version: "3.8"

services:
  localstack:
    container_name: localstack_main
    image: localstack/localstack:1.4.0
    restart: always
    ports:
      - "127.0.0.1:53:53"
      - "127.0.0.1:53:53/udp"
      - "127.0.0.1:443:443"
      - "127.0.0.1:4510-4559:4510-4559"
      - "127.0.0.1:4566:4566"
    environment:
      - DEFAULT_REGION=eu-west-3
      - LAMBDA_EXECUTOR=docker
      - LAMBDA_REMOTE_DOCKER=true
      - LAMBDA_REMOVE_CONTAINERS=true
      - DEBUG=1
      - PERSISTENCE=1
      - DNS_ADDRESS=0
      - DOCKER_HOST=unix:///var/run/docker.sock

    volumes:
      - "${LOCALSTACK_VOLUME_DIR:-./volume}:/var/lib/localstack"
      - "/var/run/docker.sock:/var/run/docker.sock"
      - ./scripts/localstack_bootstrap:/docker-entrypoint-initaws.d/
    env_file:
      - .env-localstack
```
#### Python script to reproduce 

```py
import boto3

def assume_role():
    sts_client = boto3.client(
        "sts",
        endpoint_url="http://localhost:4566",
    )
    assumed_role_object = sts_client.assume_role(
        RoleArn="arn:aws:iam::123456789101:role/fake-role",
        RoleSessionName="fake-role",
    )

    credentials = assumed_role_object["Credentials"]
    resource = boto3.client(
        "kms",
        aws_access_key_id=credentials["AccessKeyId"],
        aws_secret_access_key=credentials["SecretAccessKey"],
        aws_session_token=credentials["SessionToken"],
        region_name="eu-west-3",
        endpoint_url="http://localhost:4566",
    )

    return resource


role = assume_role()
response = role.create_key(
    KeyUsage="ENCRYPT_DECRYPT",
    CustomerMasterKeySpec="RSA_4096",
    Origin="AWS_KMS",
)

role.create_alias(
    AliasName="alias/my-custom-key", TargetKeyId=response["KeyMetadata"]["KeyId"]
)
response = role.encrypt(
    KeyId="alias/my-custom-key",
    Plaintext="Based on the boto3 documentation anything bigger than 446 bytes should raise an error",
    EncryptionAlgorithm="RSAES_OAEP_SHA_256",
)
```


### Environment

```markdown
- OS: Ubuntu 22.04.2
- LocalStack: 1.4.0
```


### Anything else?

Yes, I'm using the Pro version.

You can find information about the permissible size of plaintexts on the boto3 documentation, which is available at this link: https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/kms/client/encrypt.html.

I have implemented a solution for the issue of plaintext size verification on my Localstack forked project. However, I would like to confirm whether the lack of verification for plaintext size was intentional or not. If it was not, I am excited to contribute to the project by submitting my solution.
import base64
import hashlib
import json
import re
from datetime import datetime
from random import getrandbits
import pytest
from botocore.config import Config
from botocore.exceptions import ClientError
from cryptography.hazmat.primitives.asymmetric.padding import PKCS1v15
from cryptography.hazmat.primitives.serialization import load_der_public_key
from localstack.aws.accounts import get_aws_account_id
from localstack.services.kms.utils import get_hash_algorithm
from localstack.utils.strings import short_uid
PATTERN_KEY_ARN = re.compile(
    r"arn:(aws[a-zA-Z-]*)?:([a-zA-Z0-9-_.]+)?:([^:]+)?:(\d{12})?:key/[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}"
)
@pytest.fixture(scope="class")
def kms_client_for_region(aws_client_factory):
    def _kms_client(
        region_name: str = None,
    ):
        return aws_client_factory(region_name=region_name).kms
    return _kms_client
def _get_all_key_ids(kms_client):