### Is there an existing issue for this?

- [X] I have searched the existing issues

### Current Behavior

Updating a dynamodb item updates other binary fields in the stream into their base64 encoded form.

### Expected Behavior

Updating the dynamodb item should not affect other fields in the stream.

### How are you starting LocalStack?

With a `docker run` command

### Steps To Reproduce

#### Start LocalStack
```bash
# docker run --rm -it -p 4566:4566 -p 4510-4559:4510-4559 localstack/localstack
...
LocalStack version: 1.2.1.dev
LocalStack build date: 2022-11-04
LocalStack build git hash: a4d60b3f
```

#### Run the following
```python
from time import sleep
from uuid import uuid4
import boto3

ENDPOINT_URL = "http://localhost.localstack.cloud:4566"


def wait_for_table_active(dynamo_client, table_name):
    while True:
        response = dynamo_client.describe_table(TableName=table_name)
        table_status = response.get('Table', {}).get('TableStatus')
        if (table_status == 'ACTIVE'):
            return response
        sleep(1)


def poll_records(streams_client, shard_iterator):
    while True:
        response = streams_client.get_records(ShardIterator=shard_iterator)
        records = response.get('Records')
        shard_iterator = response.get('NextShardIterator')
        if records:
            return (shard_iterator, records)


def main():
    table_name = 'StreamBug-' + str(uuid4())

    # aws clients - switch these to run on aws
    # dynamo_client = boto3.client('dynamodb')
    # streams_client = boto3.client('dynamodbstreams')
    dynamo_client = boto3.client('dynamodb', endpoint_url=ENDPOINT_URL)
    streams_client = boto3.client('dynamodbstreams', endpoint_url=ENDPOINT_URL)

    # create DynamoDB table
    dynamo_client.create_table(
        TableName=table_name,
        KeySchema=[{
            'AttributeName': '__pkey',
            'KeyType': 'HASH'
        }],
        AttributeDefinitions=[{
            'AttributeName': '__pkey',
            'AttributeType': 'S'
        }],
        BillingMode='PAY_PER_REQUEST',
        StreamSpecification={
            'StreamEnabled': True,
            'StreamViewType': 'NEW_IMAGE',
        }
    )

    table = wait_for_table_active(
        dynamo_client=dynamo_client,
        table_name=table_name
    )

    # There is an issue where the table is marked as ACTIVE, however issueing a
    # put-item immediately does not go into the stream.
    sleep(10)

    # put a dummy item to be used with the test
    dynamo_client.put_item(
        TableName=table_name,
        Item={
            '__pkey': {'S': 'test'},
            'version': {'N': '1'},
            'data': {'B': b'\x90'},
        }
    )

    get_item_response = dynamo_client.get_item(
        TableName=table_name,
        Key={'__pkey': {'S': 'test'}}
    )

    stream_arn = table['Table']['LatestStreamArn']

    shard_id = streams_client.describe_stream(StreamArn=stream_arn)[
        'StreamDescription']['Shards'][0]['ShardId']
    shard_iterator = streams_client.get_shard_iterator(
        StreamArn=stream_arn,
        ShardId=shard_id,
        ShardIteratorType='TRIM_HORIZON'
    )['ShardIterator']

    (shard_iterator, get_records) = poll_records(
        streams_client=streams_client, shard_iterator=shard_iterator)

    dynamo_client.update_item(
        TableName=table_name,
        Key={'__pkey': {'S': 'test'}},
        UpdateExpression='SET version=:v',
        ExpressionAttributeValues={':v': {'N': '2'}}
    )

    get_item_response2 = dynamo_client.get_item(
        TableName=table_name,
        Key={'__pkey': {'S': 'test'}}
    )

    (shard_iterator, get_records_after_update) = poll_records(
        streams_client=streams_client, shard_iterator=shard_iterator)

    # cleanup
    dynamo_client.delete_table(TableName=table_name)

    print('GetItem =>', get_item_response['Item'])
    print('Stream Records =>', get_records[0]['dynamodb']['NewImage'])
    print('GetItem After Update =>', get_item_response2['Item'])
    print('Stream Records After Update =>',
          get_records_after_update[0]['dynamodb']['NewImage'])

    assert get_item_response['Item']['data'] == get_records[0]['dynamodb']['NewImage']['data']
    assert get_item_response['Item']['data'] == get_records_after_update[0]['dynamodb']['NewImage']['data']


if __name__ == "__main__":
    main()
```

The script does the following:
- Puts a new item
- Gets the new item
- Gets the item from the dynamodb stream
- Updates the `version` field on the item. Note, the `data` binary field breaks which are not part of the update
- Gets the new item
- Gets the item from the dynamodb stream

Output:
```
GetItem => {'__pkey': {'S': 'test'}, 'data': {'B': b'\x90'}, 'version': {'N': '1'}}
Stream Records => {'__pkey': {'S': 'test'}, 'version': {'N': '1'}, 'data': {'B': b'\x90'}}
GetItem After Update => {'__pkey': {'S': 'test'}, 'data': {'B': b'\x90'}, 'version': {'N': '2'}}
Stream Records After Update => {'__pkey': {'S': 'test'}, 'data': {'B': b'kA=='}, 'version': {'N': '2'}}
```

`Stream Records After Update` the `data` field is not correct.

### Environment

```markdown
- OS: MacOS 12.5.1
- LocalStack: latest
```


### Anything else?

Relates to #6786 
import json
import re
from datetime import datetime
from time import sleep
from typing import Dict
import pytest
from boto3.dynamodb.conditions import Key
from boto3.dynamodb.types import STRING
from localstack.constants import TEST_AWS_SECRET_ACCESS_KEY
from localstack.services.dynamodbstreams.dynamodbstreams_api import get_kinesis_stream_name
from localstack.testing.snapshots.transformer import SortingTransformer
from localstack.utils import testutil
from localstack.utils.aws import arns, aws_stack, queries, resources
from localstack.utils.common import json_safe, long_uid, retry, short_uid
from .test_kinesis import get_shard_iterator
PARTITION_KEY = "id"
TEST_DDB_TABLE_NAME = "test-ddb-table-1"
TEST_DDB_TABLE_NAME_2 = "test-ddb-table-2"
TEST_DDB_TABLE_NAME_3 = "test-ddb-table-3"
TEST_DDB_TAGS = [
    {"Key": "Name", "Value": "test-table"},
    {"Key": "TestKey", "Value": "true"},
]
@pytest.fixture()
def dynamodb(dynamodb_resource):