Secure Boot & TPM
Güven Zinciri

# RSA-2048 private key üret
openssl genrsa -out dev.key 2048

# RSA-4096 private key (daha uzun vadeli)
openssl genrsa -out prod.key 4096

# ECDSA P-256 (küçük cihazlar için ideal)
openssl ecparam -name prime256v1 -genkey -noout -out ec.key

# Self-signed X.509 sertifikası üret (10 yıl geçerli)
openssl req -new -x509 \
    -key dev.key \
    -out dev.crt \
    -days 3650 \
    -subj "/CN=Embedded Secure Boot Key/O=MyCompany/C=TR"

# Sertifikayı DER formatına dönüştür (U-Boot için)
openssl x509 -in dev.crt -outform DER -out dev.crt.der

# Public key'i DER olarak çıkar
openssl rsa -in dev.key -pubout -outform DER -out dev.pub.der

# İmza doğrulama — manuel test
openssl dgst -sha256 -sign dev.key -out image.sig image.bin
openssl dgst -sha256 -verify dev.pub.der -signature image.sig image.bin

# SHA-256: en yaygın, U-Boot ve HAB tarafından desteklenir
openssl dgst -sha256 image.bin

# SHA-384: daha yüksek güvenlik seviyesi
openssl dgst -sha384 image.bin

# SHA-512: TPM PCR extend için de kullanılır
openssl dgst -sha512 image.bin

# MD5 KULLANMAYIN — güvenlik uygulamaları için cryptographically broken

/dts-v1/;

/ {
    description = "Signed kernel + dtb + ramdisk";
    #address-cells = <1>;

    images {
        kernel@1 {
            description = "Linux Kernel";
            data = /incbin/("zImage");
            type = "kernel";
            arch = "arm";
            os = "linux";
            compression = "none";
            load = <0x80008000>;
            entry = <0x80008000>;
            hash@1 {
                algo = "sha256";
            };
        };
        fdt@1 {
            description = "MyBoard Device Tree";
            data = /incbin/("myboard.dtb");
            type = "flat_dt";
            arch = "arm";
            compression = "none";
            hash@1 {
                algo = "sha256";
            };
        };
        ramdisk@1 {
            description = "Initial ramdisk";
            data = /incbin/("initrd.cpio.gz");
            type = "ramdisk";
            arch = "arm";
            os = "linux";
            compression = "gzip";
            hash@1 {
                algo = "sha256";
            };
        };
    };

    configurations {
        default = "conf@1";
        conf@1 {
            description = "Boot config with signature";
            kernel = "kernel@1";
            fdt = "fdt@1";
            ramdisk = "ramdisk@1";
            signature@1 {
                algo = "sha256,rsa2048";
                key-name-hint = "dev";
                sign-images = "kernel", "fdt", "ramdisk";
            };
        };
    };
};

# Anahtar dizini oluştur
mkdir -p keys/
openssl genrsa -out keys/dev.key 2048
openssl req -new -x509 -key keys/dev.key -out keys/dev.crt \
    -days 3650 -subj "/CN=FIT Signing Key"

# FIT image oluştur ve imzala
# -f: ITS dosyası
# -k: anahtar dizini (dev.key ve dev.crt burada)
# -K: public key'in gömüleceği U-Boot DTB
# -r: required (doğrulama zorunlu kıl)
mkimage -f my.its -k keys/ -K u-boot.dtb -r my.fit

# İmzalanmış FIT'i doğrula
mkimage -l my.fit
# FIT description: Signed kernel + dtb + ramdisk
# ...  Signature:  sha256,rsa2048:dev  OK

# U-Boot DTB'ye gömülmüş public key'i doğrula
fdtdump u-boot.dtb | grep -A 5 "signature"

# FIT imza doğrulama
CONFIG_FIT=y
CONFIG_FIT_SIGNATURE=y
CONFIG_FIT_VERBOSE=y             # doğrulama detaylarını logla
CONFIG_RSA=y
CONFIG_RSA_SOFTWARE_EXP=y        # yazılım RSA (donanım yoksa)
CONFIG_SHA256=y

# Sadece imzalı image'a izin ver (unsigned image'ı reddet)
CONFIG_IMAGE_FORMAT_LEGACY=n     # eski mkimage formatını devre dışı bırak

# U-Boot ortam değişkeni: sadece verified boot
# bootcmd=bootm ${loadaddr}#conf@1

# CST NXP web sitesinden indir: https://www.nxp.com/webapp/sps/download/license.jsp?colCode=IMX_CST_TOOL
tar xf cst-3.3.2.tar.gz
cd cst-3.3.2/

# PKI ağacı oluştur (SRK + CSF + IMG key'ler)
cd keys/
./hab4_pki_tree.sh
# Do you want to use an existing CA key (y/n)?: n
# Enter key length in bits for PKI tree: 2048
# Enter PKI tree duration (years): 10
# How many Super Root Keys should be generated? 4

# SRK hash üret (OTP'ye yazılacak değer)
./srktool -h 4 -t SRK_1_2_3_4_table.bin \
    -e SRK_1_2_3_4_fuse.bin \
    -d sha256 \
    -f 1 \
    SRK1_sha256_2048_65537_v3_ca_crt.pem \
    SRK2_sha256_2048_65537_v3_ca_crt.pem \
    SRK3_sha256_2048_65537_v3_ca_crt.pem \
    SRK4_sha256_2048_65537_v3_ca_crt.pem

# SRK fuse değerini görüntüle
hexdump -C SRK_1_2_3_4_fuse.bin

[Header]
    Version = 4.2
    Hash Algorithm = sha256
    Engine = CAAM
    Engine Configuration = 0
    Certificate Format = X509
    Signature Format = CMS

[Install SRK]
    File = "../crts/SRK_1_2_3_4_table.bin"
    Source index = 0

[Install CSFK]
    File = "../crts/CSF1_1_sha256_2048_65537_v3_usr_crt.pem"

[Authenticate CSF]

[Install Key]
    Verification index = 0
    Target index = 2
    File = "../crts/IMG1_1_sha256_2048_65537_v3_usr_crt.pem"

[Authenticate Data]
    Verification index = 2
    Blocks = 0x877ff400 0x000 0x00096000 "u-boot-dtb.imx"

# CSF binary üret
./cst/linux64/bin/cst -i u-boot-csf.txt -o u-boot-csf.bin

# U-Boot binary'sine CSF ekle
objcopy --gap-fill=0xff --pad-to=0x96000 u-boot-dtb.imx u-boot-padded.imx
cat u-boot-padded.imx u-boot-csf.bin > u-boot-signed.imx

# HAB event log sorgula — U-Boot konsolunda
=> hab_status
# Secure boot disabled
# No HAB Events Found!
# (Tüm imzalar geçerliyse; hata varsa event gösterir)

# SRK hash fuse'larını yaz (GERİ ALINAMAZ!)
# fuse prog bankNo wordNo value
=> fuse prog 3 0 0xAABBCCDD   # SRK_HASH[0]
=> fuse prog 3 1 0xEEFF0011   # SRK_HASH[1]
# ... (toplam 8 word)

# SEC_CONFIG[1] fuse'unu set et — cihazı KAPAT (Closed device)
# Bu işlemden sonra imzasız binary'ler çalışmaz!
=> fuse prog 0 6 0x00000002   # SEC_CONFIG[1] = Closed

# TI SDK'dan k3-image-gen veya tisdk signing araçlarını edin
# https://git.ti.com/cgit/security-development-tools/core-secdev-k3/

git clone https://git.ti.com/git/security-development-tools/core-secdev-k3.git
cd core-secdev-k3/

# Anahtar çifti oluştur
openssl genrsa -out custMpk.pem 4096

# tiboot3.bin (SPL for AM625/AM64x) imzala
python3 scripts/gen_x509_cert.py \
    -b tiboot3.bin \
    -o tiboot3-signed.bin \
    -k custMpk.pem \
    -d sha512

# AM335x için MLO imzalama (eski yöntem)
python3 scripts/create-boot-certificate.py \
    --key custMpk.pem \
    --image u-boot-spl.bin \
    --output MLO-signed

# Hedef üzerinde; mpk-hash OTP'ye yaz
# AM335x: EFUSE_SMA (0x44E10600) — software-locked after write

# devmem ile eFuse okuma (sadece programlanmamışsa)
devmem 0x44E10600 32    # EFUSE okuma

# TI ROM sboot_enable bit'ini set et
# Bu işlem için TI'ın eHSM servisini veya özel JTAG scriptini kullanın
# Detaylar: SPRUHF5 (AM335x TRM) Section 26.3 — Secure Boot

# tpm2-tools kurulumu
sudo apt install tpm2-tools

# TPM2 cihazını listele
ls /dev/tpm*
# /dev/tpm0   /dev/tpmrm0

# Tüm PCR değerlerini oku
tpm2_pcrread
# sha256:
#   0 : 0x7D5F...  (BIOS/ROM measurement)
#   1 : 0x8A2B...  (BIOS config)
#   7 : 0x0000...  (Secure Boot state)

# Belirli PCR'ları oku
tpm2_pcrread sha256:0,1,7

# Manuel PCR extend (test için)
tpm2_pcrextend 14:sha256=$(sha256sum myfile.bin | cut -d' ' -f1)

# Quote — PCR değerlerini TPM ile imzala (remote attestation)
# Önce bir Attestation Key oluştur
tpm2_createprimary -C e -c primary.ctx
tpm2_create -G ecc -u ak.pub -r ak.priv -C primary.ctx
tpm2_load -C primary.ctx -u ak.pub -r ak.priv -c ak.ctx

# PCR 0,1,7 quote'unu al
tpm2_quote \
    -c ak.ctx \
    -l sha256:0,1,7 \
    -q $(openssl rand -hex 20) \
    -m quote.msg \
    -s quote.sig \
    -o pcrs.out

# PCR değerlerine bağlı (sealed) anahtar oluştur
# Sadece PCR 0 ve 7 belirli değerlerdeyken seal açılabilir
tpm2_createpolicy --policy-pcr -l sha256:0,7 -L pcr.policy

tpm2_create \
    -C primary.ctx \
    -i my-secret.bin \
    -u sealed.pub \
    -r sealed.priv \
    -L pcr.policy

# Seal açma (PCR değerleri eşleşirse)
tpm2_load -C primary.ctx -u sealed.pub -r sealed.priv -c sealed.ctx
tpm2_unseal -c sealed.ctx --auth session:policy.session

# Kernel config — IMA etkinleştirme
# CONFIG_IMA=y
# CONFIG_IMA_MEASURE_PCR_IDX=10
# CONFIG_IMA_APPRAISE=y
# CONFIG_INTEGRITY_SIGNATURE=y

# Kernel cmdline — IMA politikası
# ima_policy=tcb  (trusted computing base: tüm exec + mmap ölç)

# IMA ölçüm log'unu görüntüle
cat /sys/kernel/security/integrity/ima/ascii_runtime_measurements
# 10 sha256:... ima-ng sha256:... /usr/sbin/sshd
# 10 sha256:... ima-ng sha256:... /lib/x86_64-linux-gnu/libpam.so.0

# TPM PCR 10 değerini oku
tpm2_pcrread sha256:10
# Bu değer IMA log'unun tüm extend işlemlerinin sonucudur

# IMA appraise: dosya imzalarını zorla
# Kernel cmdline: ima_appraise=enforce
# Her çalıştırılabilir dosyanın xattr'ında IMA imzası olmalı:
evmctl ima_sign --key /etc/keys/signing_key.pem /usr/bin/myapp

# Mevcut TPM cihazını listele
ls /sys/kernel/security/tpm0/
# ascii_bios_measurements
# binary_bios_measurements

# IMA politika dosyası
cat /sys/kernel/security/integrity/ima/policy

# securityfs mount edilmemişse
mount -t securityfs securityfs /sys/kernel/security

# OP-TEE OS deposu
git clone https://github.com/OP-TEE/optee_os.git
cd optee_os/

# Raspberry Pi 3 için build (CFG_ARM64_core=y ile 64-bit)
make PLATFORM=rpi3 \
     CFG_ARM64_core=y \
     CROSS_COMPILE64=aarch64-linux-gnu- \
     CROSS_COMPILE=arm-linux-gnueabihf-

# AM335x (BeagleBone Black)
make PLATFORM=ti-am43xx \
     CROSS_COMPILE=arm-linux-gnueabihf-

# Çıktı: tee-pager_v2.bin, tee.elf
ls out/arm-plat-rpi3/core/
# tee.elf  tee-pager_v2.bin  tee-header_v2.bin  tee-pageable_v2.bin

#include <tee_internal_api.h>
#include <tee_internal_api_extensions.h>

/* TA UUID — uuidgen ile benzersiz üret */
#define TA_MY_UUID { 0x8aaaf200, 0x2450, 0x11e4, \
    { 0xab, 0xe2, 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } }

TEE_Result TA_CreateEntryPoint(void) {
    return TEE_SUCCESS;
}

void TA_DestroyEntryPoint(void) { }

TEE_Result TA_OpenSessionEntryPoint(uint32_t paramTypes,
                                     TEE_Param params[4],
                                     void **sessionCtx) {
    return TEE_SUCCESS;
}

void TA_CloseSessionEntryPoint(void *sessionCtx) { }

TEE_Result TA_InvokeCommandEntryPoint(void *sessionCtx,
                                       uint32_t commandID,
                                       uint32_t paramTypes,
                                       TEE_Param params[4]) {
    switch (commandID) {
    case 0: /* Örnek: AES şifreleme */
        /* ... TEE_AllocateOperation, TEE_CipherDoFinal ... */
        return TEE_SUCCESS;
    default:
        return TEE_ERROR_NOT_SUPPORTED;
    }
}

# Kernel config
# CONFIG_TEE=y
# CONFIG_OPTEE=y

# tee-supplicant daemon'ı başlat (systemd ile)
systemctl start tee-supplicant

# TEE cihaz dosyası
ls /dev/tee*
# /dev/tee0  /dev/teepriv0

# optee_client ile CA test uygulaması çalıştır
xtest   # OP-TEE test suite

# Secure storage konumu (tee-supplicant'ın yönettiği)
ls /data/tee/
# dirf.db  dirf.db.bak  (şifrelenmiş TA storage)

# cryptsetup/veritysetup kurulumu
sudo apt install cryptsetup

# squashfs rootfs oluştur (read-only, dm-verity ile uyumlu)
mksquashfs rootfs/ rootfs.squashfs -comp lz4 -noappend

# dm-verity hash tree oluştur
# --data-block-size: 4096 (sayfa boyutu)
# --hash-block-size: 4096
# Çıktı: rootfs.hash (hash tree), root hash değeri stdout'a
veritysetup format \
    rootfs.squashfs \
    rootfs.hash \
    --data-block-size=4096 \
    --hash-block-size=4096 \
    --hash=sha256
# Root hash: 7d5f8a...c3b2 (bu değeri kernel cmdline'a koy)

# dm-verity cihazı aç (çalışan sistemde test)
veritysetup open \
    rootfs.squashfs vroot \
    rootfs.hash \
    7d5f8a...c3b2   # root hash buraya

# Doğrulanmış rootfs'i mount et
mount -t squashfs -o ro /dev/mapper/vroot /mnt

# U-Boot environment
setenv bootargs "root=/dev/dm-0 \
  dm-mod.create=\"vroot,,0,ro, \
    0 $(rootfssize_sectors) verity 1 \
    /dev/mmcblk0p2 /dev/mmcblk0p3 \
    4096 4096 $(rootfs_blocks) 1 sha256 \
    7d5f8a...c3b2 salt\" \
  rootfstype=squashfs rootflags=ro"

# Hash tree doğrulamasını aç (çalışan sistemde)
veritysetup verify rootfs.squashfs rootfs.hash 7d5f8a...c3b2
# Verification succeeded.

# Kernel dm-verity log (dmesg)
dmesg | grep -i "verity"
# [    3.456789] device-mapper: verity: sha256 using implementation "sha256-generic"
# [    3.456900] device-mapper: verity: 253:0: Root hash: 7d5f...

# rpi-eeprom deposu (raspberry pi secure boot araçları)
git clone https://github.com/raspberrypi/usbboot.git
cd usbboot/secure-boot-example/

# RSA-2048 anahtar üret
openssl genrsa -out private.pem 2048
openssl rsa -in private.pem -pubout -out public.pem

# Public key hash hesapla (OTP'ye yazılacak)
python3 ../tools/rpi-eeprom-digest \
    -i public.pem \
    -o public_key_hash.bin

# rpi-eeprom-config ile OTP'ye yaz (device'ı Pi'ye bağlayın)
sudo rpi-eeprom-config --otp-public-key public.pem \
    --apply /lib/firmware/raspberrypi/bootloader/stable/pieeprom-2024-10-22.bin

# rpi-eeprom-digest ile bootloader imzala
python3 usbboot/tools/rpi-eeprom-digest \
    -i pieeprom.bin \
    -o pieeprom.signed.bin \
    -k private.pem

# Raspberry Pi üzerinde durum sorgula
vcgencmd bootloader_config | grep -i "secure"
# SECURE_BOOT_REQUIRED=0  (0=disabled, 1=enabled)

# OTP durum okuma
vcgencmd otp_dump | grep "66:"
# 66:00000000  (secure boot OTP word)

# 1. Anahtar üret
mkdir -p keys/
openssl genrsa -out keys/dev.key 2048
openssl req -new -x509 -key keys/dev.key \
    -out keys/dev.crt -days 3650 -subj "/CN=Pi Boot Key"

# 2. U-Boot build (Pi için)
export ARCH=arm64
export CROSS_COMPILE=aarch64-linux-gnu-
make rpi_4_defconfig
# menuconfig: FIT_SIGNATURE=y, RSA=y, CONFIG_OF_CONTROL=y
make -j$(nproc)

# 3. FIT image oluştur ve imzala (public key u-boot.dtb'ye gömülür)
mkimage -f pi4.its -k keys/ -K arch/arm64/dts/broadcom/bcm2711-rpi-4-b.dtb \
    -r pi4-signed.fit

# 4. Kopyala
cp u-boot.bin /boot/
cp pi4-signed.fit /boot/

# 5. config.txt'de U-Boot'u bootloader olarak ayarla
# kernel=u-boot.bin
# arm_64bit=1
# enable_uart=1