Swift Academy · บทเรียน

การปกป้องข้อมูลและการเข้ารหัส

ปกป้องไฟล์และเรียนรู้พื้นฐานของ CryptoKit

การปกป้องข้อมูลและการเข้ารหัส เป็นบทเรียน Swift Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Swift Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Swift Academy มีบทเรียนทั้งหมด 4 บทเรียน

การปกป้องข้อมูลบน iOS

iOS เข้ารหัสไฟล์บนดิสก์โดยค่าเริ่มต้น แต่คุณสามารถเลือกได้ว่า เมื่อใดจึงจะถอดรหัสเนื้อหาของไฟล์ได้ โดยใช้คลาส การปกป้องข้อมูล คลาสเหล่านี้ผูกการเข้าถึงไฟล์ไว้กับสถานะการล็อกของอุปกรณ์ เช่นเดียวกับที่คลาสการเข้าถึงของพวงกุญแจทำกับข้อมูลลับ

import Foundation
// File-level protection ties decryption to lock state.
// Set a protection class when writing sensitive files.

คลาสการปกป้อง

ระดับการปกป้องไฟล์หลักมีดังนี้: .complete (อ่านไม่ได้ขณะล็อก), .completeUnlessOpen (ยังอ่านได้หากเปิดอยู่แล้วเมื่อล็อก), .completeUntilFirstUserAuthentication (อ่านได้หลังการปลดล็อกครั้งแรก) และ .none

import Foundation
// FileProtectionType:
//   .complete
//   .completeUnlessOpen
//   .completeUntilFirstUserAuthentication (default)
//   .none
let level = FileProtectionType.complete
_ = level

การเขียนไฟล์ที่ได้รับการปกป้อง

ส่ง .completeFileProtection ในตัวเลือกการเขียนเพื่อกำหนดให้ไฟล์ได้รับการปกป้องอย่างสมบูรณ์ ขณะที่อุปกรณ์ล็อกอยู่ ระบบปฏิบัติการจะทำให้เนื้อหาไฟล์เข้าถึงไม่ได้ แม้แต่จากแอปของคุณเอง

import Foundation
func writeSecure(_ data: Data, to url: URL) throws {
    try data.write(
        to: url,
        options: [.completeFileProtection])
}

การตั้งค่าการปกป้องไฟล์ที่มีอยู่

คุณสามารถเปลี่ยนการปกป้องของไฟล์หลังจากสร้างแล้วได้ โดยตั้งค่าแอตทริบิวต์ FileAttributeKey.protectionKey ผ่าน FileManager วิธีนี้มีประโยชน์สำหรับเพิ่มความเข้มงวดในการปกป้องไฟล์ที่คุณได้รับหรือย้ายมา

import Foundation
func protect(_ url: URL) throws {
    try FileManager.default.setAttributes(
        [.protectionKey: FileProtectionType.complete],
        ofItemAtPath: url.path)
}

CryptoKit สำหรับการเข้ารหัสในแอป

เมื่อคุณจำเป็นต้องเข้ารหัสข้อมูลด้วยตัวเอง เช่น ก่อนอัปโหลด หรือเพื่อเพิ่มชั้นการปกป้องเหนือการปกป้องบนดิสก์ ให้ใช้ CryptoKit ซึ่งมีพื้นฐานการเข้ารหัสสมัยใหม่ที่ต้านทานการใช้งานผิดวิธี พร้อมค่าเริ่มต้นที่ปลอดภัย และไม่ต้องจัดการเวกเตอร์เริ่มต้นด้วยตนเองสำหรับรหัส AEAD

import CryptoKit
// CryptoKit offers hashing, symmetric & public-key
// crypto with safe, hard-to-misuse APIs.

การแฮชด้วย SHA-256

สำหรับการตรวจสอบความถูกต้องและลายนิ้วมือ SHA256 จะสร้างค่าแฮชที่มีขนาดคงที่ โปรดทราบว่าการแฮชเป็นการทำงานทางเดียวและใช้แทนการเข้ารหัสไม่ได้ อย่าแฮชรหัสผ่านโดยไม่มีค่าเกลือและ KDF ที่ทำงานช้า

import CryptoKit
import Foundation
func fingerprint(_ data: Data) -> String {
    let digest = SHA256.hash(data: data)
    return digest.map { String(format: "%02x", $0) }
        .joined()
}

คีย์สมมาตร

การเข้ารหัสแบบสมมาตรใช้ key ร่วมกันหนึ่งชุด SymmetricKey(size: .bits256) จะสร้าง key แบบสุ่มที่มีความแข็งแกร่ง เก็บ key ไว้ในพวงกุญแจ อย่าเก็บไว้ข้างข้อมูลเข้ารหัสที่ key นั้นใช้ปกป้อง

import CryptoKit
let key = SymmetricKey(size: .bits256)
// Persist this key in the Keychain, not in a file.
_ = key

การเข้ารหัสด้วย AES-GCM

AES.GCM เป็นการเข้ารหัสพร้อมยืนยันความถูกต้อง โดยเข้ารหัสข้อมูลและตรวจจับการดัดแปลงได้ในเวลาเดียวกัน seal จะคืนกล่องที่ผนึกไว้ซึ่งรวมข้อมูลเข้ารหัส นอนซ์ และแท็กยืนยันความถูกต้องไว้ด้วยกัน

import CryptoKit
import Foundation
func encrypt(_ data: Data, key: SymmetricKey)
    throws -> Data {
    let sealed = try AES.GCM.seal(data, using: key)
    return sealed.combined! // nonce + ciphertext + tag
}

การถอดรหัสและการตรวจสอบความถูกต้อง

หากต้องการถอดรหัส ให้สร้าง SealedBox ขึ้นใหม่จากข้อมูลที่รวมกัน แล้วเรียก open หากข้อมูลเข้ารหัสหรือแท็กถูกแก้ไข open จะส่งข้อผิดพลาด แท็กยืนยันความถูกต้องรับประกันความครบถ้วนของข้อมูล ดังนั้นข้อมูลที่เสียหายจะไม่ถูกถอดรหัสอย่างเงียบ ๆ

import CryptoKit
import Foundation
func decrypt(_ combined: Data, key: SymmetricKey)
    throws -> Data {
    let box = try AES.GCM.SealedBox(combined: combined)
    return try AES.GCM.open(box, using: key)
}

การสร้างคีย์จากรหัสผ่าน

อย่าใช้รหัสผ่านดิบเป็น key เด็ดขาด ให้สร้าง key ด้วย HKDF (สำหรับข้อมูลนำเข้าที่มีเอนโทรปีสูง) หรือ KDF ที่อิงตามรหัสผ่าน HKDF ของ CryptoKit จะขยายและเติมค่าเกลือให้วัสดุคีย์จนกลายเป็นคีย์สมมาตรที่เหมาะสม

import CryptoKit
import Foundation
func deriveKey(from secret: Data, salt: Data)
    -> SymmetricKey {
    return HKDF<SHA256>.deriveKey(
        inputKeyMaterial: SymmetricKey(data: secret),
        salt: salt,
        outputByteCount: 32)
}

การวางชั้นการป้องกัน

แอปที่แข็งแกร่งจะรวมการป้องกันหลายชั้นเข้าด้วยกัน: การปกป้องข้อมูลจะเข้ารหัสไฟล์ที่จัดเก็บอยู่โดยผูกกับสถานะการล็อก พวงกุญแจจะปกป้องคีย์ด้วยไบโอเมตริกซ์ และ CryptoKit จะเพิ่มการเข้ารหัสระดับแอปสำหรับข้อมูลที่กำลังส่งหรืออยู่บนคลาวด์ แต่ละชั้นยังคงล้มเหลวอย่างปลอดภัยได้ด้วยตัวเอง

import CryptoKit
import Foundation
// 1. Key lives in Keychain (biometric-gated)
// 2. Plaintext file written with .completeFileProtection
// 3. Uploads encrypted with AES.GCM before leaving device
let layers = "defense in depth"
_ = layers

ตรวจสอบอย่างรวดเร็ว

ทบทวนเหตุผลที่เลือกใช้ AES-GCM สำหรับการเข้ารหัสระดับแอป

สรุปทบทวน

คุณได้เรียนรู้เรื่องการปกป้องข้อมูลและการเข้ารหัสแล้ว:

คลาส การปกป้องข้อมูล ของไฟล์ (.complete, .completeUntilFirstUserAuthentication) ทำให้การถอดรหัสข้อมูลบนดิสก์ขึ้นอยู่กับสถานะการล็อก
CryptoKit มีการแฮชด้วย SHA-256 การสร้างคีย์ SymmetricKey และการเข้ารหัสแบบตรวจสอบสิทธิ์ด้วย AES-GCM ผ่าน seal/open
สร้างคีย์จาก HKDF และเก็บคีย์ไว้ในพวงกุญแจ อย่าเก็บไว้ข้างข้อความเข้ารหัส
ใช้การปกป้องข้อมูล พวงกุญแจ และ CryptoKit ร่วมกันเพื่อการป้องกันหลายชั้น

คำถามที่พบบ่อย

บทเรียน “การปกป้องข้อมูลและการเข้ารหัส” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การปกป้องข้อมูลและการเข้ารหัส” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Swift Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Swift Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การปกป้องข้อมูลและการเข้ารหัส”

ปกป้องไฟล์และเรียนรู้พื้นฐานของ CryptoKit คุณปฏิบัติ Swift Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Swift Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Swift Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “การปกป้องข้อมูลและการเข้ารหัส” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Swift Academy นี้ได้ไหม

ได้ บทเรียน Swift Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Swift Academy