Nybörjarguide till Ruby on Rails: Redigera autentiseringsuppgifter och krypterade hemligheter

Ruby on Rails, ofta bara kallat Rails, är ett kraftfullt ramverk för webbapplikationer som bygger på programmeringsspråket Ruby. En av dess nyckelfunktioner är möjligheten att på ett säkert sätt hantera känsliga data, såsom API-nycklar, databasuppgifter och andra hemligheter, genom krypterade inloggningsuppgifter. Denna guide är utformad för nybörjare för att förstå hur man arbetar med Rails referenssystem, med fokus på att redigera referenser och hantera krypterade hemligheter effektivt. I slutet kommer du att ha en tydlig förståelse för hur du på ett säkert sätt hanterar känslig information i din Rails-applikation, med praktiska exempel och bästa praxis.

Denna artikel förutsätter att du har en grundläggande förståelse för Ruby och Rails, till exempel hur man ställer in en Rails-applikation och navigerar i dess katalogstruktur. Om du är ny på Rails bör du överväga att granska den officiella Ruby on Rails Guider för grundläggande kunskap. Låt oss dyka in i en värld av Rails-autentiseringsuppgifter och krypterade hemligheter!

Förståelse för Rails-autentiseringsuppgifter och krypterade hemligheter

Vad är Rails-autentiseringsuppgifter?

Rails-autentiseringsuppgifter är ett säkert sätt att lagra känslig information, t.ex. API-nycklar, lösenord eller tokens, som din applikation behöver för att fungera. Till skillnad från hårdkodade värden i källkoden eller okrypterade konfigurationsfiler, krypteras Rails-uppgifter och lagras i en fil som heter config/legitimation.yml.enc. Den här filen är säker att överföra till versionshantering (t.ex. Git) eftersom den är krypterad, vilket säkerställer att känsliga data inte exponeras.

Krypteringen hanteras med hjälp av en huvudnyckel som lagras i config/master.key eller en miljöspecifik nyckel (t.ex., config/legitimationer/produktion.nyckel). Huvudnyckeln används för att kryptera och dekryptera referensfilen, och den bör aldrig använda versionskontroll för att förhindra obehörig åtkomst till dina hemligheter.

Utveckling av hemlighetshantering i Rails

Före Rails 5.1 lagrades känsliga data ofta i config/secrets.ymlsom inte var krypterade och utgjorde säkerhetsrisker om de av misstag överfördes till ett repositorium. Rails 5.1 introducerade krypterade hemligheter och Rails 5.2 och senare förfinade detta till det referenssystem som vi använder idag. I Rails 6 och senare kan du hantera miljöspecifika referenser, vilket möjliggör separata hemligheter för utvecklings-, test- och produktionsmiljöer. Denna utveckling tog itu med utmaningar i teammiljöer där det var besvärligt att dela känslig information på ett säkert sätt.

Varför använda krypterade autentiseringsuppgifter?

Krypterade referenser löser flera problem:

• Säkerhet: Känsliga data krypteras, vilket minskar risken för exponering.
• Versionskontroll: Den krypterade autentiseringsuppgifter.yml.enc filen kan säkert överföras till Git.
• Samarbete i team: Utvecklare kan dela en kodbas utan att avslöja hemligheter, med hjälp av en säkert delad huvudnyckel (t.ex. via en lösenordshanterare).
• Miljöspecifika hemligheter: Rails stöder separata autentiseringsuppgifter för olika miljöer, vilket förenklar distributionen.

Konfigurera Rails-autentiseringsuppgifter

Skapa en ny Rails-applikation

För att följa med måste du se till att du har Ruby och Rails installerat. Du kan kontrollera dina versioner med:

bash
ruby -v
rails -v

Om Rails inte är installerat, installera det med hjälp av:

bash
gem installera rails

Skapa en ny Rails-applikation:

bash
rails ny myapp
cd myapp

När du skapar en ny Rails-app genererar Rails automatiskt två viktiga filer i config katalog:

• config/legitimation.yml.enc: Den krypterade fil där inloggningsuppgifterna lagras.
• config/master.key: Den krypteringsnyckel som används för att dekryptera autentiseringsuppgifter.yml.enc.

Viktigt: Aldrig begå ett brott config/master.key till versionskontroll. Lägg till den i din .gitignore för att förhindra oavsiktlig exponering.

Kontrollera dina inloggningsuppgifter Inställning

För att verifiera att din referensfil finns, kontrollera config katalog:

bash
ls config/

Du bör se autentiseringsuppgifter.yml.enc och master.nyckel. Om master.nyckel saknas, kommer Rails att generera en första gången du redigerar inloggningsuppgifter (förklaras nedan).

Redigera Rails-autentiseringsuppgifter

Öppna filen med autentiseringsuppgifter

För att redigera inloggningsuppgifter använder du Rails-kommandot:

bash
EDITOR="vim" rails referenser:edit

Detta kommando öppnar den dekrypterade config/legitimation.yml.enc i din angivna editor (t.ex. Vim, Nano eller VS Code). Ersätt "vim" med din föredragna editor, till exempel "kod" för VS Code. Om <code.config/credentials.yml.enc eller config/master.key inte finns, kommer Rails att skapa dem.

När du kör kommandot ser du en YAML-formaterad fil. En standardfil med autentiseringsuppgifter kan se ut så här:

yaml
# Används som bashemlighet för alla MessageVerifiers i Rails, inklusive den som skyddar cookies.
secret_key_base: din_hemliga_key_base

Den hemlig_nyckel_bas är ett kritiskt värde som används för att signera och kryptera cookies och andra data i Rails. Det genereras automatiskt när du skapar en ny Rails-app.

Lägga till nya autentiseringsuppgifter

Du kan lägga till dina egna autentiseringsuppgifter i YAML-filen. Om du t.ex. vill lägga till AWS och Stripe API-nycklar ändrar du filen så här:

yaml
# config/credentials.yml.enc
aws:
    access_key_id: din_access_key_id
    hemlig_åtkomstnyckel: din_hemliga_åtkomstnyckel
stripe:
    offentlig_nyckel: test_public
    privat_nyckel: test_privat
hemlig_nyckelbas: din_hemliga_nyckelbas

Spara och stäng redigeringsverktyget. Rails kommer automatiskt att kryptera filen och spara den som config/legitimation.yml.enc. Uppgifterna är nu säkra och kan överföras till versionskontroll.

Miljöspecifika autentiseringsuppgifter (Rails 6+)

För Rails 6 och senare kan du hantera miljöspecifika autentiseringsuppgifter. Till exempel, för att redigera produktionsautentiseringsuppgifter:

bash
EDITOR="vim" rails credentials:edit --miljö produktion

Detta skapar eller redigerar config/legitimationer/produktion.yml.enc och använder config/legitimationer/produktion.nyckel för kryptering. Ett exempel på en fil med produktionsreferenser kan se ut så här:

yaml
# config/legitimationer/produktion.yml.enc
aws:
    access_key_id: prod_access_key_id
    secret_access_key: prod_secret_access_key
secret_key_base: prod_secret_key_base

På samma sätt kan du hantera utvecklings- eller testautentiseringsuppgifter med --Miljöutveckling eller --miljö test. Detta gör att du kan använda olika API-nycklar eller databasuppgifter för varje miljö.

Tillgång till autentiseringsuppgifter i din applikation

Legitimation för läsning

Du kan komma åt autentiseringsuppgifter i din Rails-applikation med hjälp av Rails.applikation.autentiseringsuppgifter. Till exempel för att hämta AWS-åtkomstnyckeln:

ruby
Rails.application.credentials.aws[:access_key_id]
# => "din_access_key_id"

För miljöspecifika autentiseringsuppgifter laddar Rails automatiskt lämplig fil baserat på RAILS_ENV miljövariabel. Till exempel under utveckling:

ruby
Rails.application.credentials.dig(:stripe, :public_key)
# => "test_public_development"

I produktionen skulle samma kod hämta produktionsnyckeln om den definieras i config/legitimationer/produktion.yml.enc.

Förenklad åtkomst med punktnotation

För enkelhetens skull stöder Rails punktnotation för åtkomst till referenser:

ruby
Rails.application.credentials.stripe.public_key
# => "test_public"

Vissa utvecklare föredrar dock att använda gräva för nästlade nycklar för att undvika fel om en nyckel saknas.

Exempel: Använda autentiseringsuppgifter i en styrenhet

Anta att du integrerar en betaltjänst som Stripe. Du kan konfigurera den i en controller med hjälp av autentiseringsuppgifter:

ruby
klass BetalningsController < ApplikationsController
    def skapa
        Stripe.api_key = Rails.application.credentials.stripe[:private_key]
        # Logik för betalningshantering
    slut
slut

Detta håller din API-nyckel säker och utanför kodbasen.

Hantering av huvudnyckel

Säkra huvudnyckeln

Den config/master.key fil (eller miljöspecifika nycklar som config/credentials/production.key</code.) är avgörande för att dekryptera autentiseringsuppgifter. Här är bästa praxis för att hantera den:

• Gör aldrig åtaganden till versionshantering: Säkerställa master.key finns i .gitignore.
• Dela säkert: Använd en lösenordshanterare eller en säker kanal (t.ex. krypterade meddelanden) för att dela nyckeln med teammedlemmarna.
• Använd miljövariabler: Alternativt kan du ställa in >RAILS_MASTER_KEY istället för att använda miljövariabeln master.nyckel. Till exempel:

bash
export RAILS_MASTER_KEY=din_master_key

Rails prioriterar RAILS_MASTER_KEY över master.nyckel fil. Detta är användbart för driftsättningsmiljöer som Heroku eller AWS.

Rotera huvudnyckeln

Om du misstänker att huvudnyckeln har äventyrats ska du rotera den:

• Generera en ny huvudnyckel:

bash
inloggningsuppgifter för rails:redigera

Detta skapar en ny config/master.key och krypterar på nytt config/legitimation.yml.enc.

• Uppdatera alla teammedlemmar och driftsättningsmiljöer med den nya nyckeln.
• Om du använder miljöspecifika autentiseringsuppgifter, upprepa för varje miljö (t.ex, rails autentiseringsuppgifter:redigera --miljö produktion).

Rotering av hemlig_nyckel_bas kommer att ogiltigförklara befintliga sessioner och cookies, så planera rotationer noggrant för att undvika att störa användarna.

Bästa praxis för Rails-autentiseringsuppgifter

1. Håll hemligheter borta från källkoden

Hårdkoda aldrig känsliga data i din applikationskod. Undvik till exempel:

Rubin
# Dålig praxis
AWS.config(access_key_id: "ditt_access_key_id")

Använd istället:

ruby
AWS.config(access_key_id: Rails.application.credentials.aws[:access_key_id])

Detta säkerställer att hemligheter förblir krypterade och säkra.

2. Använda miljöspecifika autentiseringsuppgifter

Utnyttja Rails stöd för miljöspecifika autentiseringsuppgifter för att undvika att använda utvecklingsnycklar i produktionen. Detta minskar risken för oavsiktlig felanvändning av känsliga nycklar.

3. Filtrera känslig data i loggar

Rails-loggar kan oavsiktligt exponera känsliga data. Konfigurera config.filter_parametrar i config/applikation.rb för att filtrera känsliga parametrar:

ruby
config.filter_parameters += [:lösenord, :hemlighet, :token]

Detta markerar känsliga uppgifter som [FILTRERAD] i stockar, vilket förhindrar exponering.

4. Rotera hemligheter regelbundet

Rotera regelbundet din hemlig_nyckel_bas och andra referenser för att minimera effekterna av potentiella läckor. Använd Rails rotationsmekanismer för att uppdatera cookies på ett elegant sätt.

5. Säkra din databaskonfiguration

Säkerställa konfiguration/databas.yml inte innehåller känsliga data. Använd autentiseringsuppgifter för databaslösenord:

yaml
# config/databas.yml
produktion:
adapter: postgresql
databas: 
användarnamn:  Användarnamn: <%= Rails.application.credentials.dig(:produktion, :DB_USERNAME) %
lösenord:

Detta gör att databasuppgifterna är säkra.

6. Granska din ansökan

Använd verktyg som Brakeman och bundler-audit för att skanna din Rails-applikation efter säkerhetsproblem. Integrera dem i din CI/CD-pipeline för att fånga upp problem tidigt.

Vanliga fallgropar och hur man undviker dem

1. Överlämnande av huvudnyckeln

Oavsiktligt begå config/master.key till versionshantering är ett vanligt misstag. Dubbelkolla alltid din .gitignore file:

gitignore
/config/master.key
/config/legitimationer/*.nyckel

2. Inkonsekventa autentiseringsuppgifter i miljön

När du använder miljöspecifika autentiseringsuppgifter ska du se till att nycklarna är konsekventa i olika miljöer. Om du t.ex. lägger till en randig nyckel under utveckling, lägg till den även i produktions- och testautentiseringsuppgifter, även om det är med platshållarvärden.

3. Exponering av autentiseringsuppgifter i loggar

Ofiltrerade loggar kan avslöja hemligheter. Kontrollera alltid att config.filter_parametrar innehåller alla känsliga tangenter.

4. Använda ERB i autentiseringsuppgifter

Rails har inte stöd för Embedded Ruby (ERB) i krypterade filer med autentiseringsuppgifter, så undvik att använda <%= %> syntax. Använd vanlig YAML istället.

Avancerade ämnen

Använda autentiseringsuppgifter med tjänster från tredje part

När du integrerar tjänster från tredje part som AWS, Stripe eller SendGrid ska du lagra deras API-nycklar i referenser. Till exempel

yaml
sendgrid:
    api_key: din_sendgrid_api_key

Få tillgång till den i din ansökan:

ruby
SendGrid::API.api_key = Rails.application.credentials.sendgrid[:api_key]

På så sätt blir din integration säker och underhållbar.

Kryptering av aktiva poster

För kryptering av databasfält tillhandahåller Rails Active Record Encryption (introducerad i Rails 7). Ett exempel:

ruby
klass Artikel < ApplicationRecord
    krypterar :summary, nyckel: Rails.application.credentials.active_record_encryption[:primary_key]
slut

Förvara krypteringsnyckeln i referenserna:

yaml
aktiv_rekord_kryptering:
    primär_nyckel: din_krypteringsnyckel
    nyckel_derivation_salt: din_salt

Detta möjliggör säker lagring av känsliga databasfält.

Anpassad hantering av hemligheter

För Ruby-applikationer som inte är Rails eller avancerade användningsfall kan du överväga gems som sekretsar för att hantera krypterade hemligheter. Dessa kan integreras i Rails för anpassade arbetsflöden.

Slutsats

Att hantera referenser och krypterade hemligheter i Ruby on Rails är en kritisk färdighet för att bygga säkra applikationer. Genom att utnyttja Rails inbyggda referenssystem kan du säkert lagra känsliga data, dela dem med ditt team och distribuera din applikation med tillförsikt. Från redigering config/legitimation.yml.enc till att säkra huvudnyckeln och använda miljöspecifika autentiseringsuppgifter, har den här guiden täckt det viktigaste för nybörjare.

Om du vill ta din Rails-utveckling till nästa nivå kan du överväga att samarbeta med experter som RailsCarma, en specialiserad Ruby on Rails utvecklingsföretag. RailsCarma erbjuder heltäckande tjänster, inklusive applikationsutveckling, underhåll och säkerhetsrevisioneroch hjälper dig att bygga robusta och säkra Rails-applikationer som är skräddarsydda för dina behov. Oavsett om du är nybörjare eller håller på att skala upp ett komplext projekt kan deras expertis vägleda dig genom bästa praxis och avancerade tekniker.genom att följa de metoder som beskrivs i den här guiden och utnyttja professionell support vid behov kommer du att vara väl rustad för att hantera känsliga data på ett säkert sätt i dina Rails-applikationer.