Det här inlägget är skrivet tillsammans med Justin Miles, Liv d'Aliberti och Joe Kovba från Leidos. 

Leidos är en Fortune 500-ledare inom vetenskap och teknik som arbetar för att ta itu med några av världens tuffaste utmaningar inom försvars-, underrättelse-, hemlandets säkerhet, civil- och hälsovårdsmarknaderna. I det här inlägget diskuterar vi hur Leidos arbetade med AWS för att utveckla ett tillvägagångssätt för integritetsbevarande stora språkmodeller (LLM) inferens med hjälp av AWS Nitro-enklaver.

LLM är utformade för att förstå och generera mänskligt språk och används i många branscher, inklusive myndigheter, hälsovård, finansiell och immateriell egendom. LLM:er har bred tillämpbarhet, inklusive chatbots, innehållsgenerering, språköversättning, sentimentanalys, frågesvarssystem, sökmotorer och kodgenerering. Att introducera LLM-baserad slutledning i ett system har också potential att introducera integritetshot, inklusive modellexfiltrering, dataintegritetskränkningar och oavsiktlig LLM-baserad tjänstemanipulation. Tekniska arkitekturer måste implementeras för att säkerställa att LLM:er inte exponerar känslig information under slutledning.

Det här inlägget diskuterar hur Nitro Enclaves kan hjälpa till att skydda LLM-modellinstallationer, särskilt de som använder personlig identifierbar information (PII) eller skyddad hälsoinformation (PHI). Det här inlägget är endast för utbildningsändamål och bör inte användas i produktionsmiljöer utan ytterligare kontroller.

Översikt över LLM och nitroenklaver

Ett potentiellt användningsfall är en LLM-baserad chatbot för känslig fråga som är utformad för att utföra en fråge- och svarstjänst som innehåller PII och PHI. De flesta aktuella LLM-chatbotlösningar informerar uttryckligen användarna om att de inte bör inkludera PII eller PHI när de anger frågor på grund av säkerhetsproblem. För att mildra dessa farhågor och skydda kunddata förlitar sig tjänsteägare i första hand på användarskydd som följande:

• redaction – Processen att identifiera och dölja känslig information som PII i dokument, texter eller andra former av innehåll. Detta kan åstadkommas med indata innan de skickas till en modell eller en LLM tränad att redigera sina svar automatiskt.
• Flerfaktorautentisering – En säkerhetsprocess som kräver att användare tillhandahåller flera autentiseringsmetoder för att verifiera sin identitet för att få åtkomst till LLM.
• Transport Layer Security (TLS) – Ett kryptografiskt protokoll som tillhandahåller säker kommunikation som förbättrar dataintegriteten vid överföring mellan användare och LLM-tjänsten.

Även om dessa metoder förbättrar tjänstens säkerhetsställning, är de inte tillräckliga för att skydda all känslig användarinformation och annan känslig information som kan finnas kvar utan användarens vetskap.

I vårt exempel är en LLM-tjänst utformad för att svara på frågor om anställdas hälsovårdsförmåner eller tillhandahålla en personlig pensionsplan. Låt oss analysera följande exempelarkitektur och identifiera riskområden för datasekretess.

Figur 1 – Diagram för riskområden för datasekretess

De potentiella riskområdena är följande:

1. Privilegerade användare har tillgång till instansen som innehåller servern. Oavsiktliga eller otillåtna ändringar av tjänsten kan leda till att känslig data exponeras på oavsiktliga sätt.
2. Användare måste lita på att tjänsten inte kommer att exponera eller behålla känslig information i applikationsloggar.
3. Ändringar av applikationspaket kan orsaka ändringar i tjänsten, vilket resulterar i exponering av känslig data.
4. Privilegerade användare med åtkomst till instansen har obegränsad åtkomst till LLM som används av tjänsten. Ändringar kan leda till att felaktig eller felaktig information returneras till användarna.

Nitro Enclaves ger ytterligare isolering till din Amazon Elastic Compute Cloud (Amazon EC2), som skyddar data som används från obehörig åtkomst, inklusive användare på administratörsnivå. I den föregående arkitekturen är det möjligt för en oavsiktlig ändring att resultera i att känslig data kvarstår i klartext och av misstag avslöjas för en användare som kanske inte behöver komma åt dessa data. Med Nitro Enclaves skapar du en isolerad miljö från din EC2-instans, vilket tillåter dig att allokera CPU- och minnesresurser till enklaven. Denna enklav är en mycket restriktiv virtuell maskin. Genom att köra kod som hanterar känslig data inom enklaven kommer ingen av förälderns processer att kunna se enklavdata.

Nitro Enclaves erbjuder följande fördelar:

• Minne och CPU-isolering – Den förlitar sig på Nitro Hypervisor för att isolera processorn och minnet i enklaven från användare, applikationer och bibliotek på den överordnade instansen. Den här funktionen hjälper till att isolera enklaven och din programvara och minskar ytan avsevärt för oavsiktliga händelser.
• Separat virtuell maskin – Enklaver är separerade virtuella maskiner kopplade till en EC2-instans för att ytterligare skydda och säkert behandla mycket känslig data.
• Ingen interaktiv åtkomst – Enklaver tillhandahåller endast säker lokal socketanslutning med sin överordnade instans. De har ingen beständig lagring, interaktiv åtkomst eller externt nätverk.
• Kryptografiskt intyg – Nitro Enclaves erbjuder kryptografiskt intyg, en process som används för att bevisa identiteten för en enklav och verifiera att endast auktoriserad kod körs i din enklav.
• AWS integration – Nitro Enclaves är integrerad med AWS nyckelhanteringstjänst (AWS KMS), så att du kan dekryptera filer som har krypterats med AWS KMS inne i enklaven. AWS certifikathanterare (ACM) för Nitro Enclaves låter dig använda offentliga och privata SSL/TLS-certifikat med dina webbapplikationer och servrar som körs på EC2-instanser med Nitro Enclaves.

Du kan använda dessa funktioner som tillhandahålls av Nitro Enclaves för att minska riskerna i samband med PII- och PHI-data. Vi rekommenderar att Nitro Enclaves ingår i en LLM-tjänst vid hantering av känslig användardata.

Lösningsöversikt

Låt oss undersöka arkitekturen för exempeltjänsten, nu inklusive Nitro Enclaves. Genom att införliva Nitro Enclaves, som visas i följande figur, blir LLM en säkrare chatbot för hantering av PHI- eller PII-data.

Figur 2 – Lösningsöversiktsdiagram

Användardata, inklusive PII, PHI och frågor, förblir krypterade under hela begäran-svar-processen när applikationen är värd i en enklav. Stegen som utförs under slutsatsen är följande:

1. Chatbot-appen genererar tillfälliga AWS-uppgifter och ber användaren att mata in en fråga. Frågan, som kan innehålla PII eller PHI, krypteras sedan via AWS KMS. Den krypterade användarinmatningen kombineras med de tillfälliga referenserna för att skapa den krypterade begäran.
2. Den krypterade datan skickas till en HTTP-server som är värd för Flask som en POST-begäran. Innan känslig data accepteras bör denna slutpunkt konfigureras för HTTPs.
3. Klientappen tar emot POST-begäran och vidarebefordrar den via en säker lokal kanal (till exempel vsock) till serverappen som körs inuti Nitro Enclaves.
4. Nitro Enclaves-serverappen använder de tillfälliga referenserna för att dekryptera begäran, frågar LLM och genererar svaret. De modellspecifika inställningarna lagras i enklaverna och skyddas med kryptografisk bekräftelse.
5. Serverappen använder samma tillfälliga referenser för att kryptera svaret.
6. Det krypterade svaret returneras tillbaka till chatbot-appen via klientappen som ett svar från POST-begäran.
7. Chatbot-appen dekrypterar svaret med deras KMS-nyckel och visar klartext för användaren.

Förutsättningar

Innan vi börjar behöver du följande förutsättningar för att distribuera lösningen:

Konfigurera en EC2-instans

Utför följande steg för att konfigurera en EC2-instans:

1. Starta en r5.8xlarge EC2-instans med hjälp av amzn2-ami-kernel-5.10-hvm-2.0.20230628.0-x86_64-gp2 AMI med Nitro Enclaves aktiverade.
2. Installera Nitro Enclaves CLI för att bygga och köra Nitro Enclaves-applikationer:
   • sudo amazon-linux-extras install aws-nitro-enclaves-cli -y
   • sudo yum install aws-nitro-enclaves-cli-devel -y
3. Verifiera installationen av Nitro Enclaves CLI:
   • nitro-cli –version
   • Den version som används i det här inlägget är 1.2.2
4. Installera Git och Docker för att bygga Docker-avbildningar och ladda ner applikationen från GitHub. Lägg till din instansanvändare till Docker-gruppen ( är din IAM-instansanvändare):
   • sudo yum install git -y
   • sudo usermod -aG ne <USER>
   • sudo usermod -aG docker <USER>
   • sudo systemctl start docker && sudo systemctl enable docker
5. Starta och aktivera Nitro Enclaves allocator och vsock proxytjänster:
   • sudo systemctl start nitro-enclaves-allocator.service && sudo systemctl enable nitro-enclaves-allocator.service
   • sudo systemctl start nitro-enclaves-vsock-proxy.service && sudo systemctl enable nitro-enclaves-vsock-proxy.service

Nitro Enclaves använder en lokal socket-anslutning som kallas vsock för att skapa en säker kanal mellan den överordnade instansen och enklaven.

När alla tjänster har startats och aktiverats startar du om instansen för att verifiera att alla användargrupper och tjänster körs korrekt:

sudo shutdown -r now

Konfigurera Nitro Enclaves tilldelningstjänst

Nitro Enclaves är en isolerad miljö som anger en del av instansens CPU och minne för att köra enklaven. Med Nitro Enclaves allocator-tjänsten kan du ange hur många CPU:er och hur mycket minne som kommer att tas från den överordnade instansen för att köra enklaven.

Ändra enklavens reserverade resurser med en textredigerare (för vår lösning allokerar vi 8 CPU och 70,000 XNUMX MiB minne för att ge tillräckligt med resurser):

vi /etc/nitro_enclaves/allocatory.yaml

Figur 3 – AWS Nitro Enclaves Allocator Service Configuration

Klona projektet

När du har konfigurerat EC2-instansen kan du ladda ner koden för att köra den känsliga chatboten med en LLM inuti Nitro Enclaves.

Du måste uppdatera server.py fil med lämpligt KMS-nyckel-ID som du skapade i början för att kryptera LLM-svaret.

1. Klona GitHub-projektet:
   • cd ~/ && git clone https://<THE_REPO.git>
2. Navigera till projektmappen för att bygga enclave_base Docker-bild som innehåller Nitro Enclaves Software Development Kit (SDK) för kryptografiska verifieringsdokument från Nitro Hypervisor (detta steg kan ta upp till 15 minuter):
   • cd /nitro_llm/enclave_base
   • docker build ./ -t “enclave_base”

Spara LLM i EC2-instansen

Vi använder öppen källkod Bloom 560m LLM för naturlig språkbehandling för att generera svar. Denna modell är inte finjusterad till PII och PHI, men visar hur en LLM kan leva inuti en enklav. Modellen måste också sparas på den överordnade instansen så att den kan kopieras in i enklaven via Dockerfilen.

1. Navigera till projektet:
   • cd /nitro_llm
2. Installera de nödvändiga kraven för att spara modellen lokalt:
   • pip3 install requirements.txt
3. Kör save_model.py app för att spara modellen i /nitro_llm/enclave/bloom katalogen:
   • python3 save_model.py

Bygg och kör Nitro Enclaves-bilden

För att köra Nitro Enclaves måste du skapa en enklavbildsfil (EIF) från en Docker-bild av din applikation. Dockerfilen som finns i enklavkatalogen innehåller filerna, koden och LLM som kommer att köras inuti enklaven.

Att bygga och driva enklaven tar flera minuter att slutföra.

1. Navigera till roten av projektet:
   • cd /nitro_llm
2. Bygg enklavbildfilen som enclave.eif:
   • nitro-cli build-enclave --docker-uri enclave:latest --output-file enclave.eif

Figur 4 – AWS Nitro Enclaves Byggresultat

När enklaven är byggd kommer en serie unika hash- och plattformskonfigurationsregister (PCR) att skapas. PCR:erna är en kontinuerlig mätning för att bevisa identiteten för hårdvaran och applikationen. Dessa PCR kommer att krävas för kryptografisk bekräftelse och användas under uppdateringssteget för KMS-nyckelpolicyn.

3. Kör enklaven med resurserna från allocator.service (lägger till --attach-console argument i slutet kommer att köra enklaven i felsökningsläge):
   • nitro-cli run-enclave --cpu-count 8 --memory 70000 --enclave-cid 16 --eif-path enclave.eif

Du måste tilldela minst fyra gånger EIF-filstorleken. Detta kan ändras i allocator.service från tidigare steg.

4. Kontrollera att enklaven körs med följande kommando:
   • nitro-cli describe-enclaves

Figur 5 – AWS Nitro Enclave Beskriv kommando

Uppdatera KMS-nyckelpolicyn

Utför följande steg för att uppdatera din KMS-nyckelpolicy:

1. Välj på AWS KMS-konsolen Kundhanterade nycklar i navigeringsfönstret.
2. Sök efter nyckeln som du genererade som en förutsättning.
3. Välja Redigera på nyckelpolitiken.
4. Uppdatera nyckelpolicyn med följande information:
   • Ditt konto-ID
   • Ditt IAM-användarnamn
   • Den uppdaterade Cloud9-miljöinstansrollen
   • Handlingar kms:Encrypt och kms:Decrypt
   • Enklavera PCR:er (till exempel PCR0, PCR1, PCR2) till din nyckelpolicy med en villkorssats

Se följande nyckelpolicykod:

{
   "Version":"2012-10-17",
   "Id":"key-default-1",
   "Statement":[
      {
         "Sid":"Enable User permissions",
         "Effect":"Allow",
         "Principal":{
            "AWS":"arn:aws:iam:::user/"
         },
         "Action":[
            "kms:CreateAlias",
            "kms:CreateKey",
            "kms:DeleteAlias",
            "kms:Describe*",
            "kms:GenerateRandom",
            "kms:Get*",
            "kms:List*",
            "kms:TagResource",
            "kms:UntagResource",
            "iam:ListGroups",
            "iam:ListRoles",
            "iam:ListUsers"
         ],
         "Resource":"*"
      },
      {
         "Sid":"Enable Enclave permissions",
         "Effect":"Allow",
         "Principal":{
            "AWS":"arn:aws:iam:::role/"
         },
         "Action":[
            "kms:Encrypt",
            "kms:Decrypt"
         ],
         "Resource":"*",
         "Condition":{
            "StringEqualsIgnoreCase":{
               "kms:RecipientAttestation:PCR0":"",
               "kms:RecipientAttestation:PCR1":"",
               "kms:RecipientAttestation:PCR2":""
            }
         }
      }
   ]
}

Spara chatbot-appen

För att efterlikna en känslig fråga chatbot-applikation som lever utanför AWS-kontot måste du spara chatbot.py app och kör den i Cloud9-miljön. Din Cloud9-miljö kommer att använda sin instansroll för tillfälliga referenser för att ta bort behörigheter från EC2 som kör enklaven. Slutför följande steg:

1. Öppna den miljö du skapade på Cloud9-konsolen.
2. Kopiera följande kod till en ny fil som chatbot.py in i huvudkatalogen.
3. Installera de nödvändiga modulerna:
   • pip install boto3
   • Pip install requests
4. På Amazon EC2-konsolen, notera IP-adressen som är kopplad till din Nitro Enclaves-instans.
5. Uppdatera URL-variabeln i http://<ec2instanceIP>:5001.

"""
Modules for a basic chatbot like application and AWS communications
"""
import base64
import requests
import boto3
 
def get_identity_document():
    """
    Get identity document for current EC2 Host
    """
    identity_doc = requests.get(
        "http://169.254.169.254/latest/dynamic/instance-identity/document", timeout=30)
    return identity_doc
 
def get_region(identity):
    """
    Get account of current instance identity
    """
    region = identity.json()["region"]
    return region
 
def get_account(identity):
    """
    Get account of current instance identity
    """
    account = identity.json()["accountId"]
    return account
 
def set_identity():
    """
    Set region and account for KMS
    """
    identity = get_identity_document()
    region = get_region(identity)
    account = get_account(identity)
    return region, account
 
def prepare_server_request(ciphertext):
    """
    Get the AWS credential from EC2 instance metadata
    """
    instance_prof = requests.get(
        "http://169.254.169.254/latest/meta-data/iam/security-credentials/", timeout=30)
    instance_profile_name = instance_prof.text
 
    instance_prof_json = requests.get(
        f"http://169.254.169.254/latest/meta-data/iam/security-credentials/{instance_profile_name}",
        timeout=30)
    response = instance_prof_json.json()
 
    credential = {
        'access_key_id': response['AccessKeyId'],
        'secret_access_key': response['SecretAccessKey'],
        'token': response['Token'],
        'region': REGION,
        'ciphertext': ciphertext
    }
    return credential
 
def get_user_input():
    """
    Start chatbot to collect user input
    """
    print("Chatbot: Hello! How can I assist you?")
    user_input = input('Your Question: ')
    return user_input.lower()
 
def encrypt_string(user_input, alias, kms):
    """
    Encrypt user input using AWS KMS
    """
    file_contents = user_input
    encrypted_file = kms.encrypt(KeyId=f'alias/{alias}', Plaintext=file_contents)
    encrypted_file_contents = encrypted_file[u'CiphertextBlob']
    encrypted_file_contents_base64 = base64.b64encode(encrypted_file_contents)
    return encrypted_file_contents_base64.decode()
 
def decrypt_data(encrypted_data, kms):
    """
    Decrypt the LLM response using AWS KMS
    """
    try:
        ciphertext_blob = base64.b64decode(encrypted_data)
        response = kms.decrypt(CiphertextBlob=ciphertext_blob)
        decrypted_data = response['Plaintext'].decode()
        return decrypted_data
    except ImportError as e_decrypt:
        print("Decryption failed:", e_decrypt)
        return None
 
REGION, ACCOUNT = set_identity()
  
def main():
    """
    Main function to encrypt/decrypt data and send/receive with parent instance
    """
    kms = boto3.client('kms', region_name=REGION)
    alias = "ncsnitro"
    user_input = get_user_input()
    encrypted_input = encrypt_string(user_input, alias, kms)
    server_request = prepare_server_request(encrypted_input)
    url = 'http://<EC2 Instance Private IP>:5001'
    x = requests.post(url, json = server_request)
    response_body = x.json()
    llm_response = decrypt_data(response_body["EncryptedData"], kms)
    print(llm_response)
 
if __name__ == '__main__':
    main()

6. Kör chatbot-applikationen:

• • python3 chat.py

När den är igång kommer terminalen att fråga efter användarinput och följa arkitekturdiagrammet från tidigare för att generera ett säkert svar.

Kör den privata chatboten för frågor och svar

Nu när Nitro Enclaves är igång på EC2-instansen kan du säkrare ställa frågor till din chatbot PHI och PII. Låt oss titta på ett exempel.

Inom Cloud9-miljön ställer vi en fråga till vår chatbot och anger vårt användarnamn.

Figur 6 – Ställ en fråga till chatboten

AWS KMS krypterar frågan, som ser ut som följande skärmdump.

Figur 7 – Krypterad fråga

Den skickas sedan till enklaven och frågas om den säkrade LLM. Frågan och svaret för LLM kommer att se ut som följande skärmdump (resultatet och det krypterade svaret är endast synliga i enklaven i felsökningsläge).

Figur 8 – Svar från LLM

Resultatet krypteras sedan med AWS KMS och returneras till Cloud9-miljön för att dekrypteras.

Figur 9 – Slutligt dekrypterat svar

Städa upp

Utför följande steg för att rensa upp dina resurser:

1. Stoppa EC2-instansen som skapats för att hysa din enklav.
2. Ta bort Cloud9-miljön.
3. Ta bort KMS-nyckeln.
4. Ta bort EC2-instansrollen och IAM-användarbehörigheter.

Slutsats

I det här inlägget visade vi upp hur man använder Nitro Enclaves för att distribuera en LLM-fråga och svarstjänst som säkrare skickar och tar emot PII- och PHI-information. Detta distribuerades på Amazon EC2, och enklaverna är integrerade med AWS KMS som begränsar åtkomsten till en KMS-nyckel, så endast Nitro Enclaves och slutanvändaren får använda nyckeln och dekryptera frågan.

Om du planerar att skala den här arkitekturen för att stödja större arbetsbelastningar, se till att modellvalsprocessen matchar dina modellkrav med EC2-resurser. Dessutom måste du överväga den maximala förfrågningsstorleken och vilken inverkan det kommer att ha på HTTP-servern och slutledningstid mot modellen. Många av dessa parametrar är anpassningsbara genom modellen och HTTP-serverinställningarna.

Det bästa sättet att fastställa de specifika inställningarna och kraven för din arbetsbelastning är genom att testa med en finjusterad LLM. Även om det här inlägget bara inkluderade naturlig språkbehandling av känsliga data, kan du modifiera den här arkitekturen för att stödja alternativa LLM:er som stöder ljud, datorseende eller multimodaliteter. Samma säkerhetsprinciper som lyfts fram här kan tillämpas på data i vilket format som helst. Resurserna som används för att skapa detta inlägg finns tillgängliga på GitHub repo.

Dela hur du ska anpassa den här lösningen för din miljö i kommentarsfältet.

Om författarna

Justin Miles är molningenjör inom Leidos Digital Modernization Sector under Office of Technology. På fritiden tycker han om att golfa och resa.

Liv d'Aliberti är forskare inom Leidos AI/ML Accelerator under Office of Technology. Deras forskning fokuserar på maskininlärning som bevarar integritet.

Chris Renzo är en Sr. Solution Architect inom AWS Defence and Aerospace organisationen. Utanför jobbet tycker han om en balans mellan varmt väder och resor.

Joe Kovba är Vice President inom Leidos Digital Modernization Sector. På fritiden tycker han om att döma fotbollsmatcher och spela softboll.

• SEO-drivet innehåll och PR-distribution. Bli förstärkt idag.
• PlatoData.Network Vertical Generative Ai. Styrka dig själv. Tillgång här.
• PlatoAiStream. Web3 Intelligence. Kunskap förstärkt. Tillgång här.
• Platoesg. Kol, CleanTech, Energi, Miljö, Sol, Avfallshantering. Tillgång här.
• PlatoHealth. Biotech och kliniska prövningar Intelligence. Tillgång här.
• Källa: https://aws.amazon.com/blogs/machine-learning/large-language-model-inference-over-confidential-data-using-aws-nitro-enclaves/