### 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 
self, dynamodb_client, dynamodb_create_table_with_parameters, snapshot
    ):
        table_name = f"test-ddb-table-{short_uid()}"
        dynamodb_create_table_with_parameters(
            TableName=table_name,
            KeySchema=[{"AttributeName": "id", "KeyType": "HASH"}],
            AttributeDefinitions=[{"AttributeName": "id", "AttributeType": "S"}],
            ProvisionedThroughput={"ReadCapacityUnits": 5, "WriteCapacityUnits": 5},
            Tags=TEST_DDB_TAGS,
        )
        dynamodb_client.put_(TableName=table_name, Item={"id": {"S": "Fred"}})
        response = dynamodb_client.batch_write_(
            RequestItems={
                table_name: [
                    {"DeleteRequest": {"Key": {"id": {"S": "Fred"}}}},
                    {"PutRequest": {"Item": {"id": {"S": "Bob"}}}},
                ]
            }
        )
        snapshot.match("BatchWriteResponse", response)
    @pytest.mark.xfail(reason="this test flakes regularly in CI")
    def test_dynamodb_stream_records_with_update_(