Du kan skydda en ZIP-fil med ett lösenord med hjälp av kommandotinjen "Zip" i ett Unix-skript. Så här, tillsammans med förklaringar och bästa praxis:
1. Använda alternativet `-p` (minst säkert - rekommenderas inte för känslig data):
`` `bash
#!/bin/bash
Zip_file ="my_archive.zip"
Lösenord ="my_secret_password"
Files_to_zip ="file1.txt fil2.pdf katalog1"
zip -p "$ lösenord" "$ zip_file" "$ files_to_zip"
Echo "Zip File '$ zip_file' skapat med lösenord (mindre säker metod)."
`` `
* Förklaring:
* `Zip -p" $ Password "" $ zip_file "" $ files_to_zip "`:Detta kommando skapar zip -filen.
* `-p" $ lösenord "`:Anger lösenordet direkt på kommandoraden. Detta är problemet!
* `" $ Zip_file "`:Namnet på zip -filen för att skapa.
* `" $ Files_to_zip "`:de filer och kataloger du vill inkludera i zip -arkivet. Använd citat för att hantera mellanslag i filnamn.
* Säkerhetsrisk: Denna metod är den * minst * säkra. Lösenordet skickas direkt som ett kommandoradsargument. Det här betyder:
* Synlig i processlistan: Alla med åtkomst till systemets processlista ("PS" -kommandot) kan se lösenordet.
* lagras i Shell History: Lösenordet kan sparas i skalhistorikfilen (t.ex. `.Bash_History ').
2. Använda alternativet "-e" med Interactive Password Prompt (bättre):
`` `bash
#!/bin/bash
Zip_file ="my_archive.zip"
Files_to_zip ="file1.txt fil2.pdf katalog1"
zip -e "$ zip_file" "$ files_to_zip"
Echo "Zip File '$ zip_file' skapad med lösenord (interaktiv prompt)."
`` `
* Förklaring:
* `Zip -e" $ zip_file "" $ files_to_zip "`:
* `-e`:Aktiverar kryptering. Kommandot "Zip" uppmanar dig att ange och verifiera lösenordet interaktivt.
* Säkerhetsförbättring: Detta är bättre än `-p` eftersom lösenordet inte lagras på kommandoraden. Det har matats in direkt vid prompten.
* Begränsningar:
* icke-skriptbar: Kräver mänsklig interaktion för att ange lösenordet, vilket gör det olämpligt för helt automatiserade skript.
3. Använda alternativet `-p` (något bättre, fortfarande inte idealisk för känslig data):
`` `bash
#!/bin/bash
Zip_file ="my_archive.zip"
Lösenord ="my_secret_password"
Files_to_zip ="file1.txt fil2.pdf katalog1"
zip -p "$ lösenord" "$ zip_file" "$ files_to_zip"
Echo "Zip File '$ zip_file' skapat med lösenord (versaler p - mindre osäker än små bokstäver p)."
`` `
* Förklaring: `-P` liknar` -p` men behandlar lösenordet som en bokstavlig sträng och tolkar inga skalmetakaracters i den.
* Säkerhet: Något bättre än `-p` eftersom det undviker oavsiktlig tolkning av skal, men lösenordet är * fortfarande * på kommandoraden och sårbar för processlista och historikexponering. Undvik detta för verkligt känsliga data.
4. Använda `OpenSSL` för säkrare kryptering (rekommenderas för känslig data):
Detta tillvägagångssätt använder "OpenSSL" för att skapa ett säkert krypterat arkiv. Detta anses vanligtvis vara en mer robust metod för att skydda känslig data jämfört med den inbyggda "Zip" -krypteringen.
`` `bash
#!/bin/bash
Zip_file ="my_archive.zip.enc" # Observera .enc -förlängningen
Files_to_zip ="file1.txt fil2.pdf katalog1"
# Skapa ett tjärarkiv först
tar -czf tmp_archive.tar.gz "$ files_to_zip"
# Kryptera tjärarkivet med OpenSSL
OpenSSL ENC -AES -256 -CBC -SALT -IN TMP_ARCHIVE.tar.gz -out "$ Zip_file"
# Ta bort det tillfälliga tjärarkivet
rm tmp_archive.tar.gz
Echo "Encrypted Archive '$ Zip_File' skapat med OpenSSL."
`` `
* Förklaring:
* `tjära -czf tmp_archive.tar.gz" $ files_to_zip "`:Skapar ett gzippat tjärarkiv för filerna. `Tar 'är ett standard UNIX -verktyg för arkiveringsfiler och kataloger. `Gzip` komprimerar arkivet.
* `OpenSSL ENC -AES -256 -CBC -SALT -IN TMP_ARCHIVE.tar.gz -out" $ zip_file "`:Krypterar TAR -arkivet med OpenSSL.
* `OpenSSL ENC`:åberopar kommandot OpenSSL -kryptering.
* `-AES-256-CBC`:Anger AES (Advanced Encryption Standard) -algoritmen med en 256-bitars nyckel i CBC (Cipher Block Chaining) -läge. AES-256 är en stark krypteringsalgoritm.
* `-Salt`:lägger till ett slumpmässigt salt till lösenordet före kryptering. Detta är * avgörande * för att förhindra attacker av regnbågen. OpenSSL genererar saltet automatiskt.
* `-in tmp_archive.tar.gz`:Anger inmatningsfilen (TAR-arkivet).
* `-out" $ Zip_file "`:Anger utgångsfilen (det krypterade arkivet). Förlängningen `.enc` är en vanlig konvention.
* Lösenordsprompt: OpenSSL kommer * att uppmana * dig för lösenordet på kommandoraden. Detta är bättre än att överföra det som ett argument.
* Säkerhetsfördelar:
* Stark kryptering: Använder AES-256, en mycket stark krypteringsalgoritm.
* saltat lösenord: Saltning förhindrar föreskrivna attacker (regnbågtabeller) som försöker gissa lösenord.
* Inget lösenord på kommandoraden: Lösenordet matas in interaktivt och undviker exponering i processlistor eller skalhistorik.
* dekryptering: För att dekryptera filen använder du följande "OpenSSL" -kommando (du kommer att uppmanas till lösenordet):
`` `bash
OpenSSL ENC -D -AES -256 -CBC -SALT -IN MY_ARCHIVE.ZIP.ENC -OUT TMP_ARCHIVE.TAR.GZ
tjära -xzf tmp_archive.tar.gz
rm tmp_archive.tar.gz
`` `
* `-d`:dekryptera
* `-x`:Extract
5. Använda en lösenordsfil eller miljövariabel (mer skriptbar, med varningar):
Om du absolut behöver en skriptbar lösning * utan * användarinteraktion kan du använda en lösenordsfil eller miljövariabel. Men du måste förstå säkerhetskonsekvenserna.
`` `bash
#!/bin/bash
Zip_file ="my_archive.zip.enc"
Files_to_zip ="file1.txt fil2.pdf katalog1"
Lösenord_file ="lösenord.txt"
# Se till att lösenordsfilen finns och har lämpliga behörigheter (skrivskyddad för ägaren)
om [! -f "$ Password_file"]; sedan
ECHO "ERROR:Password File '$ Password_file' inte hittat."
avfart 1
fi
CHMOD 400 "$ Password_file" # skrivskyddad för ägaren
# Skapa ett tjärarkiv först
tar -czf tmp_archive.tar.gz "$ files_to_zip"
# Kryptera tjärarkivet med OpenSSL
OpenSSL ENC -AES -256 -CBC -SALT -PASS FIL:"$ Password_file" -in TMP_ARCHIVE.tar.gz -out "$ Zip_file"
# Ta bort det tillfälliga tjärarkivet
rm tmp_archive.tar.gz
ECHO "Krypterat arkiv '$ Zip_file' skapat med OpenSSL (lösenord från filen)."
`` `
* Förklaring:
* `Password_File =" Password.txt "`:Definierar sökvägen till filen som innehåller lösenordet. Den här filen är avgörande för att säkra ordentligt!
* `CHMOD 400" $ Password_file "`:Ställer in behörigheterna i lösenordsfilen till skrivskyddad för ägaren. Detta är viktigt för att förhindra obehörig åtkomst.
* `OpenSSL ENC -AES -256 -CBC -SALT -PASS -FIL:" $ Password_file "...`:`-Pass -filen:" $ Password_File "" -alternativet säger OpenSL att läsa lösenordet från den angivna filen.
* Säkerhetsöverväganden:
* Lösenordsfilskydd: Filen "Password.txt" måste vara extremt väl skyddad.
* Förvara den utanför Webroot (om du är på en webbserver).
* Ge det restriktiva behörigheter (t.ex. `CHMOD 400 Password.txt` - skrivskyddad för ägaren).
* Kontrollera inte det i versionskontroll (git, etc.).
* Miljövariabler: Ett alternativ är att lagra lösenordet i en miljövariabel. Använd `exportera lösenord =your_secret_password '(men var medveten om att detta fortfarande kan vara synligt via` ps' eller i skalhistorien om du inte är försiktig). Använd sedan `-Pass Env:Password` i kommandot 'OpenSSL'. aldrig hårddisken lösenordet direkt i skriptet.
* Nyckelhantering: För mycket känsliga data kan du överväga att använda Key Management Systems (KMS) eller hårdvarusäkerhetsmoduler (HSM) istället för att lagra lösenord i filer eller miljövariabler.
Viktiga överväganden och bästa praxis:
* krypteringsalgoritm: Använd alltid starka krypteringsalgoritmer som AES-256. Undvik äldre, svagare algoritmer som ZIP:s inbyggda kryptering (som lätt bryts).
* saltning: Använd alltid ett salt med ditt lösenord. OpenSSLs alternativ "-salt" gör detta automatiskt.
* Lösenordskomplexitet: Välj starka, komplexa lösenord som är svåra att gissa. Använd en lösenordsgenerator om det behövs.
* nyckelrotation: Ändra regelbundet (rotera) dina krypteringsnycklar/lösenord.
* Säker lagring: Skydda dina krypteringsnycklar/lösenord så noggrant när du skyddar själva uppgifterna.
* princip för minst privilegium: Ge skriptet endast de nödvändiga behörigheterna för att utföra sin uppgift.
* Revision: Logga när kryptering och dekrypteringsoperationer inträffar för revisionsändamål.
* Felhantering: Inkludera felhantering i ditt skript för att fånga potentiella problem och förhindra att känsliga data exponeras.
* Tillfälliga filer: Om du använder tillfälliga filer (som i "OpenSSL" -exemplen), se till att ta bort dem säkert efter användning. "Strimat" eller "torka" kan användas för detta, men de kräver noggrann användning. Att helt enkelt använda "RM" lämnar data återvinnbara.
* Undvik ZIP:s inbyggda kryptering: Den inbyggda krypteringen i "Zip" -verktyget anses vanligtvis vara svagt och bör undvikas för känslig data. `OpenSSL` är mycket säkrare.
Att välja rätt metod:
* högsta säkerhet (och vanligtvis enklaste): Använd `OpenSSL` och ange manuellt lösenordet i prompten.
* Skriftligt, men med risker: Om du behöver en skriptbar lösning, använd 'OpenSSL' med en lösenordsfil eller miljövariabel, men * bara * om du kan garantera säkerheten för lösenordslagring. Förstå riskerna. Tänk på KMS eller HSM för mycket känslig data.
* Undvik `zip -p` och` zip -p` till varje pris för känslig data.
Kom ihåg att anpassa dessa skript efter dina specifika behov och överväg noggrant säkerhetskonsekvenserna för varje metod. Prioritera alltid datasäkerhet vid hantering av känslig information.
