### 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.
aliased_key_id = kms_create_key()["KeyId"]
        comparison_key_id = kms_create_key()["KeyId"]
        alias_name = f"alias/{short_uid()}"
        kms_create_alias(AliasName=alias_name, TargetKeyId=aliased_key_id)
        assert _get_alias(aws_client.kms, alias_name, aliased_key_id) is not None
        assert _get_alias(aws_client.kms, alias_name, comparison_key_id) is None
    @pytest.mark.aws_validated
    def test_all_types_of_key_id_can_be_used_for_encryption(
        self, kms_create_key, kms_create_alias, aws_client
    ):
        def get_alias_arn_by_alias_name(kms_client, alias_name):
            for response in kms_client.get_paginator("list_aliases").paginate(KeyId=key_id):
                for alias_list_entry in response["Aliases"]:
                    if alias_list_entry["AliasName"] == alias_name:
                        return alias_list_entry["AliasArn"]
            return None
        key_metadata = kms_create_key()
        key_arn = key_metadata["Arn"]
        key_id = key_metadata["KeyId"]
        alias_name = kms_create_alias(TargetKeyId=key_id)
        alias_arn = get_alias_arn_by_alias_name(aws_client.kms, alias_name)
        assert alias_arn
        aws_client.kms.encrypt(KeyId=key_arn, Plaintext="encrypt-me")
        aws_client.kms.encrypt(KeyId=key_id, Plaintext="encrypt-me")
        aws_client.kms.encrypt(KeyId=alias_arn, Plaintext="encrypt-me")
        aws_client.kms.encrypt(KeyId=alias_name, Plaintext="encrypt-me")
    @pytest.mark.aws_validated
    def test_create_multi_region_key(self, kms_create_key):