Enhancing Data Lake Security: A Guide to PII Scanning in S3 buckets

Private AI
Apr 9, 2024
Share this post
Sharing to FacebookSharing to LinkedInSharing to XSharing to Email

Introduction

Data lakes are messy with vast amounts of data scattered everywhere as they serve as repositories for a myriad of structured and unstructured data. Amidst this chaos lies a treasure trove of valuable and sometimes sensitive information, including data that can directly or indirectly identify individuals, known as Personally Identifiable Information (PII). As organizations utilize data lakes like Amazon S3 for various downstream applications, including AI-driven apps, data analytics, machine learning, and collaborative data sharing, it is crucial to handle this data lake security. As a best practice, proactive risk management strategies are essential to prevent data leaks. Continuously monitoring S3 buckets for PII has emerged as a common technique of a data security strategy. Not only does effective PII scanning mitigate the risk of breaches, but it also reinforces data governance practices, ensuring integrity and security across the board.

In this guide, we'll delve into the details of how you can enhance S3 data lake security through PII scanning using Private AI.

What is PII?

Personally Identifiable Information (PII) refers to any data that could identify an individual, either directly or in combination with other data points. This includes information such as full names, social security numbers, driver's license numbers, passport numbers, email addresses, phone numbers, home addresses, and biometric data such as fingerprints or facial recognition data but also so-called indirect identifiers like postal code, date of birth, race, or gender. Additionally, domain-specific data such as financial information like bank account numbers and credit card numbers, as well as medical information such as patient records and health insurance information, are also considered PII. Essentially, any data point that can be used on its own or when combined with other data to identify a person constitutes PII. Protecting this information is crucial to safeguarding individuals' privacy, data lake security, and preventing identity theft or other malicious activities.

Why is safeguarding PII important?

From compliance mandates to data governance and data lake security considerations, here are a few reasons why safeguarding PII is important:

Compliance and Regulatory Requirements: Adhering to stringent laws such as the General Data Protection Regulation (GDPR) and the Health Insurance Portability and Accountability Act (HIPAA) is mandatory for those organizations to which these laws apply. Failure to comply can result in severe legal consequences and hefty fines. Therefore, it is imperative for organizations to stay informed about these laws and ensure full compliance to avoid potential penalties.

Data Governance: PII management is a fundamental element of data governance. For example, particular rules apply mandating the maximum retention period of PII, after which the data must be destroyed or anonymized. By implementing proper policies and controls for safeguarding PII, organizations can instill trust in their data processes and enhance and enhance data lake security.

Pre-Data Migration and Cloud Adoption: If you’re thinking about migrating to the cloud, it is essential to conduct thorough pre-assessments of your data assets and implement stringent security measures to safeguard PII from unauthorized access or breaches. Knowing what PII is included in your data sets will ensure that the measures you take are proportionate to the risk associated with the cloud migration process and the harm that would result from a breach.

Data Analytics and Machine Learning: Data analytics and machine learning, by their very nature, consume vast amounts of data to train algorithms and derive insights. Consequently, the responsible collection and processing of PII is paramount to preserving user privacy and preventing the misuse of personal data. By implementing robust privacy protection measures, organizations can ensure the data lake security and that sensitive information is used responsibly and in accordance with privacy regulations.

Data Sharing and Collaboration: Effective data sharing and collaboration initiatives must prioritize the proper management of PII at every stage. Whether sharing data internally or externally, organizations must adhere to relevant regulations and laws governing the processing of PII to mitigate risks and maintain the trust of stakeholders.

Why is safeguarding PII important?

The boundaries of Amazon AWS Macie & Comprehend

Limited to the AWS Ecosystem: Macie works well for basic identifiable entities, especially when used within the AWS ecosystem. This could be a drawback for businesses using a wide variety of cloud services, or those storing data on-premises.

Cost: Both the AWS services (Amazon Comprehend and Macie) are billed based on usage, which means that if you have a large amount of data to process, it can become expensive. Private AI provides flexibility, allowing for on-premise and cloud deployments with predictable pricing.

Languages: Macie may not support less common languages or dialects. Non-Latin scripts may also pose a challenge. To name only two examples, note that Hindi and Punjabi are not supported by Macei.

Consider the following text in Hindi:

"एमिली पटेल, उम्र 25 वर्ष, 1010 चेरी एवेन्यू, मेट्रो सिटी में रहती हैं। उनका ईमेल पता है emily.patel@fastmail.com, और फोन नंबर है 555-1111। उनका मेट्रो बैंक में खाता है, खाता संख्या 654321 है।"

This translates to:

"Emily Patel, aged 25, resides at 1010 Cherry Avenue, Metro City. Her email address is emily.patel@fastmail.com, and her phone number is 555-1111. She has an account at Metro Bank with the account number 654321."

Private AI handled this file seamlessly and identified the PII. The example below is available through the Private AI File Web Demo.

 

The boundaries of Amazon AWS Macie & Comprehend

File types : AWS Comprehend and Macie may be limited in the types of files they can process. For example, they can’t process audio files. Private AI can handle multiple files, including support for documents (PDF, Word, Excel and Powerpoint), Images (JPEG, TIFF, PNF, BMP), Audio (WAV, MP3, MP4, M4A and WebM) and more.

In contrast to existing solutions like AWS Macie and Amazon Comprehend, Private AI offers a comprehensive solution to the challenges associated with managing PII. In this guide, we will go through a scenario with Private AI where we can: 1. Detect and deidentify PII in JSON format stored in S3; and 2. Extract PII entities and metadata for analytical purposes.

So, let's get started...

Scenario: De-identifying PII in JSON format file stored in S3 and also the extracted PII stored in MySQL, which can be queried by entity type to find metadata of files.

In this scenario, we'll illustrate how to automate the redaction of JSON files stored in an S3 bucket. These files contain sensitive information, and we want to maskPII before storing them in separate, redacted S3 buckets and also store the extracted entities including metadata in MySQL.

The setup involves configuring a Lambda function to process newly created JSON files in the source S3 bucket. Upon detection of a new file, the Lambda function triggers, takes the JSON text as input, applies redaction to mask PII, and then saves the redacted file into a designated S3 bucket.

Below is the configuration snippet from a serverless framework's `serverless.yml` file tailored for this task:

s3_json_pipeline:
  handler: app.s3_json_pii_pipeline
  events:
    - s3:
        bucket: ${self:custom.bucket}
        event: s3:ObjectCreated:*
        existing: true
        rules:
          - prefix: lakehouse/health_raw/
          - suffix: .json

In summary, this configuration sets up the Lambda function named `s3_json_pii_pipeline` to respond to S3 events when new objects are created in the specified bucket. It's designed to process both new objects and any existing ones that meet the criteria of having keys prefixed with `lakehouse/health_raw/` and suffixed with `.json`.

Data Lake Security

Pre-requisites

Note: Ideally, for security and privacy reasons, you might want to run the container in your own VPC. Refer to the VPC installation documents to learn more.

For this scenario, we will assume that the container is already installed and exposes a REST API endpoint.

Step 1: Set up the S3 client in Python

To interact with Amazon S3 services from Python, we'll define a `setup_s3_client` method. This method creates an S3 client using Boto3 in the specified AWS region (defaulting to "eu-west-2"). The client is configured with up to 10 retries on request failures, ensuring robustness in communication with the S3 service.

1import os
2import boto3
3from botocore.config import Config
4
5def setup_s3_client():
6    region_name = os.environ.get("AWS_DEFAULT_REGION", "eu-west-2")
7    retry_config = Config(
8        region_name=region_name,
9        signature_version="v4",
10        retries={"max_attempts": 10, "mode": "standard"}
11    )
12    return boto3.client("s3", config=retry_config)

Next, let’s proceed with creating the buckets for our scenario.

Step 2: Create the buckets in python

To create a raw S3 bucket, execute the following bash script on the terminal, which leverages the AWS CLI. We will specify the desired bucket name (in this case `datalake_test_raw`) and the region (`eu-west-2`):


1echo "Creating bucket datalake_test_raw in region eu-west-2"
2export RAW_BUCKET_NAME="datalake-test-raw"
3export REGION="eu-west-2"
4aws s3api create-bucket --bucket ${RAW_BUCKET_NAME} --region ${REGION} --create-bucket-configuration LocationConstraint=${REGION}

Similarly, to create a processed S3 bucket, execute the following command, specifying the bucket name (`datalake_test_processed`) and the region (`eu-west-2`):

1echo "Creating bucket datalake_test_processed in region eu-west-2"
2export PROCESSED_BUCKET_NAME="datalake-test-processed"
3aws s3api create-bucket --bucket ${PROCESSED_BUCKET_NAME} --region ${REGION} --create-bucket-configuration LocationConstraint=${REGION}

Step 3: Define helper functions to read and write files from S3

The 'read_file_from_s3' function is responsible for getting a file from an S3 bucket by using the provided bucket name and key. On the other hand, the 'write_file_to_s3' function can be used to upload content to an S3 bucket with a provided key.

1def read_file_from_s3(bucket, key):
2   try:
3       response = s3.get_object(Bucket=bucket, Key=key)
4       return response["Body"].read().decode("utf-8")
5   except Exception as e:
6       logger.error(f"Error reading file from S3: {e}")
7       return None
8
9
10
11def write_file_to_s3(bucket, key, content):
12   try:
13       s3.put_object(Body=content, Bucket=bucket, Key=key)
14   except Exception as e:
15       logger.error(f"Error writing file to S3: {e}")



Step 4: Setup the Private AI PAIClient for de-identification

De-identification is a process of cleansing a record or dataset by removing PII. In this code snippet, we set up the PAIClient client object in python, which will leverage Private AI's de-identification API. Entities and processed text are extracted from the response.

1from privateai_client import PAIClient
2from privateai_client import request_objects
3
4
5client = PAIClient(
6   url="https://api.private-ai.com/deid/", api_key=os.environ.get("PRIVATEAI_API_KEY")
7)
8entity_detection_obj = request_objects.entity_detection_obj(
9   accuracy="high", return_entity=True)
10processed_text_obj = request_objects.processed_text_obj(type="MARKER")



Step 5: Create the database and get the database object

In this step, let us create the database table to store the de-identification response and entity metadata. This table is defined in an RDS(MySQL) database.

1DROP TABLE IF EXISTS files_pii_entities_log;
2CREATE TABLE IF NOT EXISTS files_pii_entities_log
3(
4   -- File name, assumed to be a unique identifier for each file
5   file_name          VARCHAR(255)  NOT NULL,
6
7
8   entity_id                 INT AUTO_INCREMENT,
9
10
11   -- Processed text entities
12   entities_processed_text VARCHAR(255)  NULL,
13
14
15   -- Raw text entities
16   entities_text           VARCHAR(255)  NULL,
17
18
19   -- Location of entities within the document
20   entities_location       VARCHAR(1000) NULL,
21
22
23   -- Best label for the identified entity
24   entities_best_label     VARCHAR(255)  NULL,
25
26
27   -- All labels associated with the entity
28   entities_labels         VARCHAR(1000) NULL,
29
30
31   -- Flag indicating if the response was in JSON format
32   json_response           TINYINT(1)    NULL,
33
34
35   -- HTTP status code of the response
36   status_code             INT           NULL,
37
38
39   -- Flag indicating if the operation was successful
40   ok                      TINYINT(1)    NULL,
41
42
43   -- Detected languages in the file
44   languages_detected      VARCHAR(1000) NULL,
45
46
47   -- Timestamp when the record was created
48   created_at              TIMESTAMP     NOT NULL DEFAULT CURRENT_TIMESTAMP,
49
50
51   -- Timestamp when the record was last updated
52   updated_at              TIMESTAMP     NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
53
54
55   -- Composite primary key for uniqueness and indexing
56   PRIMARY KEY (file_name, entity_id)
57);
58-- Consider adding indexes based on the query patterns. For example:
59-- CREATE INDEX idx_entities ON files_pii_entities_log(entities_text);
60-- CREATE INDEX idx_status ON files_pii_entities_log(status_code);

Now, let’s extend the Python code to create a helper function for the database.

The `get_mysql_connection` function tries to connect to a MySQL database using SSL verification. If successful, it returns the connection object; otherwise, it prints an error and returns `None`.

Each time a JSON document is created in S3, we remove PII from the JSON document (de-identification) and store in an RDS database the extracted entities that are discovered and entity metadata, such as the label of the entity with maximum likelihood. This helper method gets a connection object to the persistent RDS (MySQL engine) database that stores the metadata.

1def get_mysql_connection() -> Optional[pymysql.connections.Connection]:
2ssl_ca_file_path = certifi.where()
3print(f"ssl_ca_file_path: {ssl_ca_file_path}")
4if not ssl_ca_file_path or not os.path.exists(ssl_ca_file_path):
5    print("SSL CA file path not found for this OS.")
6    return None
7try:
8    connection = pymysql.connect(
9        host=os.environ.get("RDS_ENDPOINT"),
10        port=int(os.environ.get("RDS_PORT")),
11        user=os.environ.get("RDS_USER"),
12        password=os.environ.get("RDS_PASSWORD"),
13        database="pii",
14        ssl_verify_cert=True,
15        ssl_verify_identity=True,
16        ssl_ca=certifi.where(),
17    )
18    return connection
19except pymysql.MySQLError as e:
20    print(f"Database connection error: {e}")
21    return None


For this function to work, you need to set up several environment variables including the RDS endpoint, port, username and password. You can find this information for your RDS instance by following the instructions here.

Step 6: Define helper function to de-identify and process JSON text

De-identification is a process of cleansing a record or dataset by removing PII. The Python helper function we are going to define does three things:

  1. Text Processing Request Preparation:

  - Constructs a request object `process_text_request` using some `process_text_obj` method/function. This object likely contains the text to be processed, settings for processing, and possibly some pre-initialized objects for entity detection and processed text.

  - Calls the external Private AI service through PAIClient (`client.process_text`).

  1. Logs response and entity metadata :

  - If the database connection is successful, it logs information about identified entities into a database table (`files_pii_entities_log`) based on the response received from the external service.

  - It iterates over `response.entities[0]` (assuming it's a list) to extract information for logging.

  - Inserts data into the database table using `insert_into_database()` function.

  1. Returns output:

  - Prints some information including the processed text from the response.

  - Returns the processed text (first element of `response.processed_text`) as the result of the function.

1def deidentify_using_private_ai(text: str, key: str) -> Optional[str]:
2process_text_request = request_objects.process_text_obj(
3    text=[text],
4    link_batch=False,
5    entity_detection=entity_detection_obj,
6    processed_text=processed_text_obj,)
7response = client.process_text(process_text_request)
8print(
9    f"response: {response} response: {response.languages_detected} and labels: {response.best_labels}")
10languages_detected = ", ".join([
11        f"{lang}: {score}"
12        for lang_score in response.languages_detected
13        for lang, score in lang_score.items()])
14
15
16# Establish a database connection
17connection = None
18try:
19    connection = get_mysql_connection()
20    if not connection:
21        return None
22
23
24    entities_log_query = "INSERT INTO files_pii_entities_log (file_name, entities_processed_text, entities_text, entities_location, entities_best_label, entities_labels, json_response, status_code, ok, languages_detected) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s);"
25    for entity in response.entities[0]:
26        print(f"Inserting entity {entity}")
27        data_tuple = (
28            key,
29            entity.get("processed_text"),
30            entity.get("text")
31          str(entity.get("location")),entity.get("best_label"),
32            str(entity.get("labels")),
33            response.json_response,
34            response.status_code,
35            response.ok,
36            languages_detected,
37        )
38        insert_into_database(connection, entities_log_query, data_tuple)
39
40
41except pymysql.MySQLError as e:
42    print(f"Database operation error: {e}")
43finally:
44    if connection:
45        connection.close()
46
47
48print(f"Processed text: {response.processed_text}")
49return response.processed_text[0]



Step 7: Wrap the code around a lambda function handler

Next, let’s define an AWS Lambda function that processes file uploads to an S3 bucket. Invoked by an event, it checks for a valid event body and extracts the bucket name and file key. Then, it reads and interprets the file content as JSON. If successful, it calls ‘deidentify_using_private_ai’. Finally, it returns a response containing metadata and the deidentified content.

def deidentified_content(event, context):
status_code = 200


if not event.get('body'):
    return {'statusCode': 400, 'body': json.dumps({'message': 'No body was found'})}

# Get file information from S3 event
s3_event = json.loads(event["body"])
if not s3_event.get("bucket_name") or not s3_event.get("file_key"):
    return {'statusCode': 400, 'body': json.dumps({'message': 'No bucket_name or file_key was found'})}

bucket_name = s3_event["bucket_name"]
file_key = s3_event["file_key"]


# Read json content from S3
file_content = read_file_from_s3(bucket_name, file_key)
# Safely load the content to json
try:
    file_content = json.loads(file_content)
except Exception as e:
    return {'statusCode': 400, 'body': json.dumps({'message': f'Error reading file from S3: {e}'})}


# Deidentify and process the content
deidentified_content = deidentify_using_private_ai(json.dumps(file_content), file_key)
print(f"deidentified_content: {deidentified_content}")

data = {
    "statusCode": status_code,
    "bucket_name": bucket_name,
    "file_key": file_key,
    "demasked_content": deidentified_content
}
return json.dumps(data)



Step 8: Create a serverless config and deploy the lambda function

The YAML snippet defines a serverless function named "redact_pii" with a corresponding handler "app.deidentified_content". This function is triggered by an HTTP GET request at the "/redactpii" endpoint.

1functions:
2  redact_pii:
3    handler: app.deidentified_content
4    events:
5      - httpApi:
6          path: /redactpii
7          method: get



The command "sls deploy" is used to deploy the serverless lambda application, enabling the execution of the defined functions in the cloud environment.

To deploy the serverless lambda application, use the command:

sls deploy



Step 9: Deidentify a single JSON document

To interact with the /redactpii HTTP endpoint, provide a JSON file named "sample.json" with prefix ‘lakehouse/health_raw/’ in the datalake-test-raw bucket.

// Input JSON
{
  "users": [
    {
      "name": "John Doe",
      "email": "johndoe@example.com",
      "phone": "123-456-7890",
      "address": "123 Main St, City, State, 12345"
    }
  ]
}

// Output JSON:
{
  "users": [
    {
      "name": "[NAME_1]",
      "email": "[EMAIL_ADDRESS_1]",
      "phone": "[PHONE_NUMBER_1]",
      "address": "[LOCATION_ADDRESS_1]"
    }
  ]
}

This output JSON demonstrates redacted PII, replacing names with "[NAME_1]", email addresses with "[EMAIL_ADDRESS_1]", phone numbers with "[PHONE_NUMBER_1]", and addresses with "[LOCATION_ADDRESS_1]". Now, if the JSON documents that were previously generated by Mockaroo have other PII fields such as id, which maps to HEALTHCARE_NUMBER, those field values will be redacted as well.

Step 10: Analyze the metadata

Now, imagine a scenario where you're interested in retrieving JSON files containing metadata of types "phone_number" or "numerical_pii". Leveraging the metadata stored in the RDS (MySQL) database, you can execute a straightforward query, such as the one shown below:

SELECT
   *
FROM
   files_pii_entities_log
WHERE
   entities_best_label IN ('PHONE_NUMBER', 'NUMERICAL_PII');



Step 11: Setup automation to invoke the lambda function

To automate the invocation of your Lambda function upon each S3 upload, you can follow the tutorial provided by AWS. By setting this up, you can seamlessly integrate your Lambda function with S3, ensuring that it automatically executes in response to file uploads in S3, thereby streamlining your PII handling workflow.

Conclusion

This guide offers an in-depth walkthrough on Data Lake Security and effectively scanning and redacting Personally Identifiable Information (PII) within AWS S3 buckets. It underscores the significance of actively monitoring S3 buckets for PII in contexts such as compliance, data governance, and pre-data migration phases. The discussion delves into the limitations of native AWS tools like Comprehend and Macie, proposing Private AI as a versatile alternative with support for diverse file types, languages, and cloud environments. Step-by-step instructions are provided for setting up essential AWS and Private AI components, along with scripts for automating PII redaction in S3 buckets and logging detections to an RDS database for analytical purposes.

Get started with Private AI today

Data Left Behind: AI Scribes’ Promises in Healthcare

Data Left Behind: Healthcare’s Untapped Goldmine

The Future of Health Data: How New Tech is Changing the Game

Why is linguistics essential when dealing with healthcare data?

Why Health Data Strategies Fail Before They Start

Private AI to Redefine Enterprise Data Privacy and Compliance with NVIDIA

EDPB’s Pseudonymization Guideline and the Challenge of Unstructured Data

HHS’ proposed HIPAA Amendment to Strengthen Cybersecurity in Healthcare and how Private AI can Support Compliance

Japan's Health Data Anonymization Act: Enabling Large-Scale Health Research

What the International AI Safety Report 2025 has to say about Privacy Risks from General Purpose AI

Private AI 4.0: Your Data’s Potential, Protected and Unlocked

How Private AI Facilitates GDPR Compliance for AI Models: Insights from the EDPB's Latest Opinion

Navigating the New Frontier of Data Privacy: Protecting Confidential Company Information in the Age of AI

Belgium’s Data Protection Authority on the Interplay of the EU AI Act and the GDPR

Enhancing Compliance with US Privacy Regulations for the Insurance Industry Using Private AI

Navigating Compliance with Quebec’s Act Respecting Health and Social Services Information Through Private AI’s De-identification Technology

Unlocking New Levels of Accuracy in Privacy-Preserving AI with Co-Reference Resolution

Strengthened Data Protection Enforcement on the Horizon in Japan

How Private AI Can Help to Comply with Thailand's PDPA

How Private AI Can Help Financial Institutions Comply with OSFI Guidelines

The American Privacy Rights Act – The Next Generation of Privacy Laws

How Private AI Can Help with Compliance under China’s Personal Information Protection Law (PIPL)

PII Redaction for Reviews Data: Ensuring Privacy Compliance when Using Review APIs

Independent Review Certifies Private AI’s PII Identification Model as Secure and Reliable

To Use or Not to Use AI: A Delicate Balance Between Productivity and Privacy

To Use or Not to Use AI: A Delicate Balance Between Productivity and Privacy

News from NIST: Dioptra, AI Risk Management Framework (AI RMF) Generative AI Profile, and How PII Identification and Redaction can Support Suggested Best Practices

Handling Personal Information by Financial Institutions in Japan – The Strict Requirements of the FSA Guidelines

日本における金融機関の個人情報の取り扱い - 金融庁ガイドラインの要件

Leveraging Private AI to Meet the EDPB’s AI Audit Checklist for GDPR-Compliant AI Systems

Who is Responsible for Protecting PII?

How Private AI can help the Public Sector to Comply with the Strengthening Cyber Security and Building Trust in the Public Sector Act, 2024

A Comparison of the Approaches to Generative AI in Japan and China

Updated OECD AI Principles to keep up with novel and increased risks from general purpose and generative AI

Is Consent Required for Processing Personal Data via LLMs?

The evolving landscape of data privacy legislation in healthcare in Germany

The CIO’s and CISO’s Guide for Proactive Reporting and DLP with Private AI and Elastic

The Evolving Landscape of Health Data Protection Laws in the United States

Comparing Privacy and Safety Concerns Around Llama 2, GPT4, and Gemini

How to Safely Redact PII from Segment Events using Destination Insert Functions and Private AI API

WHO’s AI Ethics and Governance Guidance for Large Multi-Modal Models operating in the Health Sector – Data Protection Considerations

How to Protect Confidential Corporate Information in the ChatGPT Era

Unlocking the Power of Retrieval Augmented Generation with Added Privacy: A Comprehensive Guide

Leveraging ChatGPT and other AI Tools for Legal Services

Leveraging ChatGPT and other AI tools for HR

Leveraging ChatGPT in the Banking Industry

Law 25 and Data Transfers Outside of Quebec

The Colorado and Connecticut Data Privacy Acts

Unlocking Compliance with the Japanese Data Privacy Act (APPI) using Private AI

Tokenization and Its Benefits for Data Protection

Private AI Launches Cloud API to Streamline Data Privacy

Processing of Special Categories of Data in Germany

End-to-end Privacy Management

Privacy Breach Reporting Requirements under Law25

Migrating Your Privacy Workflows from Amazon Comprehend to Private AI

A Comparison of the Approaches to Generative AI in the US and EU

Benefits of AI in Healthcare and Data Sources (Part 1)

Privacy Attacks against Data and AI Models (Part 3)

Risks of Noncompliance and Challenges around Privacy-Preserving Techniques (Part 2)

Enhancing Data Lake Security: A Guide to PII Scanning in S3 buckets

The Costs of a Data Breach in the Healthcare Sector and its Privacy Compliance Implications

Navigating GDPR Compliance in the Life Cycle of LLM-Based Solutions

What’s New in Version 3.8

How to Protect Your Business from Data Leaks: Lessons from Toyota and the Department of Home Affairs

New York's Acceptable Use of AI Policy: A Focus on Privacy Obligations

Safeguarding Personal Data in Sentiment Analysis: A Guide to PII Anonymization

Changes to South Korea’s Personal Information Protection Act to Take Effect on March 15, 2024

Australia’s Plan to Regulate High-Risk AI

How Private AI can help comply with the EU AI Act

Comment la Loi 25 Impacte l'Utilisation de ChatGPT et de l'IA en Général

Endgültiger Entwurf des Gesetzes über Künstliche Intelligenz – Datenschutzpflichten der KI-Modelle mit Allgemeinem Verwendungszweck

How Law25 Impacts the Use of ChatGPT and AI in General

Is Salesforce Law25 Compliant?

Creating De-Identified Embeddings

Exciting Updates in 3.7

EU AI Act Final Draft – Obligations of General-Purpose AI Systems relating to Data Privacy

FTC Privacy Enforcement Actions Against AI Companies

The CCPA, CPRA, and California's Evolving Data Protection Landscape

HIPAA Compliance – Expert Determination Aided by Private AI

Private AI Software As a Service Agreement

EU's Review of Canada's Data Protection Adequacy: Implications for Ongoing Privacy Reform

Acceptable Use Policy

ISO/IEC 42001: A New Standard for Ethical and Responsible AI Management

Reviewing OpenAI's 31st Jan 2024 Privacy and Business Terms Updates

Comparing OpenAI vs. Azure OpenAI Services

Quebec’s Draft Regulation Respecting the Anonymization of Personal Information

Version 3.6 Release: Enhanced Streaming, Auto Model Selection, and More in Our Data Privacy Platform

Brazil's LGPD: Anonymization, Pseudonymization, and Access Requests

LGPD do Brasil: Anonimização, Pseudonimização e Solicitações de Acesso à Informação

Canada’s Principles for Responsible, Trustworthy and Privacy-Protective Generative AI Technologies and How to Comply Using Private AI

Private AI Named One of The Most Innovative RegTech Companies by RegTech100

Data Integrity, Data Security, and the New NIST Cybersecurity Framework

Safeguarding Privacy with Commercial LLMs

Cybersecurity in the Public Sector: Protecting Vital Services

Privacy Impact Assessment (PIA) Requirements under Law25

Elevate Your Experience with Version 3.5

Fine-Tuning LLMs with a Focus on Privacy

GDPR in Germany: Challenges of German Data Privacy (Part 2)

Comply with US Executive Order on Safe, Secure, and Trustworthy Artificial Intelligence using Private AI

How to Comply with EU AI Act using PrivateGPT