HMAC ve HKDF: Güvenli Veri İmzalama ve Anahtar Türetme İşlemleri

Birçok güvenlik protokolü ve uygulama, veri bütünlüğünü doğrulamak ve kimlik doğrulama sağlamak için mesaj imzalama algoritmalarına ihtiyaç duyar. Bu algoritmalar, güvenli bir şekilde verileri imzalayarak yetkilendirilmemiş değişikliklerden korunur ve verilerin güvenilir bir kaynaktan geldiğini doğrular. HMAC, güvenli bir şekilde veri imzalamak için kullanılan bir algoritmadır. HMAC, Hash fonksiyonları ve gizli bir anahtarın birleşimi ile çalışır.

HMAC (Hash-based Message Authentication Code)

• HMAC, özet (hash) fonksiyonlarıyla birlikte kullanılan bir mesaj kimlik doğrulama kodudur.
  
• HMAC, gizli bir anahtarla hesaplanan ve mesajın doğruluğunu doğrulamak için kullanılan bir koddur.
  
• HMAC algoritması, saldırılara karşı dirençli olacak şekilde tasarlanmıştır ve yaygın olarak kullanılmaktadır.
  
• HMAC, özellikle veri bütünlüğünü sağlama ve kimlik doğrulama işlemlerinde kullanılır.

HMAC için Python örneği:

import hmac
import hashlib

# Anahtar ve mesajı tanımlayın
key = b'mykey'
message = b'Hello, World!'

# HMAC'yi hesaplayın
hmac_hash = hmac.new(key, message, hashlib.sha256).hexdigest()

print("HMAC:", hmac_hash)

package main
import (
 "crypto/hmac"
 "crypto/rand"
 "crypto/sha256"
 "crypto/sha512"
 "encoding/hex"
 "fmt"
 "io"
 "os"
)
func getSalt(n int) []byte {
 nonce := make([]byte, n)
 if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
  panic(err.Error())
 }
 return (nonce)
}
func main() {
 key:="000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F"
 m := "The quick brown fox jumps over the lazy dog"
 argCount := len(os.Args[1:])
 if argCount > 0 {
  m = os.Args[1]
 }
 if argCount > 1 {
  key = os.Args[2]
 }
 var secretKey, _ = hex.DecodeString(key)
message := []byte(m)
 // salt := getSalt(16)
 fmt.Printf("Message: %s\n", m)
 fmt.Printf("Key: %x\n", secretKey)
 // fmt.Printf("\nSalt: %x\n", salt)
 hash := hmac.New(sha256.New, []byte(secretKey))
 hash.Write(message)
 // hash.Write(salt)
 fmt.Printf("\nHMAC-Sha256: %x", hash.Sum(nil))
 hash = hmac.New(sha512.New, []byte(secretKey))
 hash.Write(message)
 // hash.Write(salt)
 fmt.Printf("\n\nHMAC-sha512: %x", hash.Sum(nil))
}

Örnek çıktı

Message: The quick brown fox jumps over the lazy dog
Key: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f
HMAC-Sha256: f87ad256151fc7b4c5dffa4adb3ebe911a8eeb8a8ebdee3c2a4a8e5f5ec02c32
HMAC-sha512: 0623d51f882717efa360aa2217d0b554b57ea018eb518178b23045941a6ae24450af5c980f6ebca94ca5314a8590991b4eab6daa3f0c109345433f44ee234d00

HKDF (HMAC-based Key Derivation Function)

• HKDF, gizli anahtarların türetilmesi için kullanılan bir algoritmadır.
  
• HKDF, HMAC’in güvenilirliğini temel alır ve özellikle kriptografik anahtar türetme işlemlerinde kullanılır.
  
• HKDF, başlangıç anahtarını gizli anahtar ve rastgele birleştirerek güvenli bir şekilde yeni anahtarlar üretir.
  
• HKDF, güvenli anahtar türetme işlemlerinde kullanılan standart bir yöntemdir ve birçok güvenlik protokolünde tercih edilir.

HKDF için Python örneği:

import hmac
import hashlib

# HKDF fonksiyonunu tanımlayın
def hkdf_extract(salt, key_material):
    return hmac.new(salt, key_material, hashlib.sha256).digest()

def hkdf_expand(prk, info, length):
    output = b""
    t = b""
    for i in range((length + 255) // 256):
        t = hmac.new(prk, t + info + bytes([i + 1]), hashlib.sha256).digest()
        output += t
    return output[:length]

# Anahtar malzemesi ve tuzu tanımlayın
key_material = b'mykeymaterial'
salt = b'mysalt'

# HKDF'yi uygulayın
prk = hkdf_extract(salt, key_material)
output_key = hkdf_expand(prk, b'info', 32)  # 32 byte (256 bit) uzunluğunda anahtar üretin

print("Output Key:", output_key.hex())

package main
import (
 "crypto/rand"
 "crypto/sha256"
 "fmt"
 "io"
 "os"
 "golang.org/x/crypto/hkdf"
)
func getSalt(n int) []byte {
 nonce := make([]byte, n)
 if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
  panic(err.Error())
 }
 return (nonce)
}
func main() {
 hash := sha256.New
 s := "The quick brown fox jumps over the lazy dog"
 salt := getSalt(hash().Size())
 info := []byte("")
 argCount := len(os.Args[1:])
 if argCount > 0 {
  s = os.Args[1]
 }
 secret := []byte(s)
 kdf := hkdf.New(hash, secret, salt, info)
 key1 := make([]byte, 16)
 _, _ = io.ReadFull(kdf, key1)
 fmt.Printf("Secret: %s\n", s)
 fmt.Printf("HKDF 16 byte key: %x\n", key1)
 key2 := make([]byte, 32)
 _, _ = io.ReadFull(kdf, key2)
 fmt.Printf("HKDF 32 byte key: %x\n", key2)
}

Örnek

Secret: The quick brown fox jumps over the lazy dog
Salt: c357e487d08ebb3a219d7370b26d424c7c642275e8a76cab1544d47b4c9458f4
HKDF 16 byte key: 2332a50d3306be40cfc044b0a48d5818
HKDF 32 byte key: 2b368335f306b6cf5ffd97b3077e0181de940d5e6c6eafd9b22dbeedf464c38a

Kaynak: https://medium.com/asecuritysite-when-bob-met-alice/hmac-and-hkdf-3cc9ffef37ac