90 lines
2.6 KiB
Go
90 lines
2.6 KiB
Go
package crypto
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"crypto/rsa"
|
|
"crypto/sha256"
|
|
"crypto/x509"
|
|
"encoding/base64"
|
|
"encoding/hex"
|
|
"encoding/pem"
|
|
"fmt"
|
|
"log"
|
|
)
|
|
|
|
// HashToken hashes a token using SHA-256.
|
|
func HashToken(token string) string {
|
|
hash := sha256.Sum256([]byte(token))
|
|
return hex.EncodeToString(hash[:])
|
|
}
|
|
|
|
// VerifyToken compares a plaintext token with a stored hash.
|
|
func VerifyToken(token, storedHash string) bool {
|
|
return HashToken(token) == storedHash
|
|
}
|
|
|
|
func main() string {
|
|
// 1. Generiere einen privaten Schlüssel
|
|
privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
|
|
if err != nil {
|
|
log.Fatalf("Fehler beim Generieren des privaten Schlüssels: %v", err)
|
|
}
|
|
|
|
// 2. Extrahiere den öffentlichen Schlüssel
|
|
publicKey := &privateKey.PublicKey
|
|
|
|
// 3. Beispieltext zum Verschlüsseln
|
|
plainText := "Dies ist ein geheimer String!"
|
|
|
|
// 4. Verschlüssle den Text mit dem öffentlichen Schlüssel
|
|
encryptedBytes, err := rsa.EncryptPKCS1v15(rand.Reader, publicKey, []byte(plainText))
|
|
if err != nil {
|
|
log.Fatalf("Fehler beim Verschlüsseln: %v", err)
|
|
}
|
|
|
|
// Kodierung des verschlüsselten Textes in Base64 für Lesbarkeit
|
|
encryptedString := base64.StdEncoding.EncodeToString(encryptedBytes)
|
|
fmt.Println("Verschlüsselter Text (Base64):", encryptedString)
|
|
|
|
// 5. Entschlüssle den Text mit dem privaten Schlüssel
|
|
decryptedBytes, err := rsa.DecryptPKCS1v15(rand.Reader, privateKey, encryptedBytes)
|
|
if err != nil {
|
|
log.Fatalf("Fehler beim Entschlüsseln: %v", err)
|
|
}
|
|
|
|
// 6. Gib den entschlüsselten Text aus
|
|
decryptedString := string(decryptedBytes)
|
|
fmt.Println("Entschlüsselter Text:", decryptedString)
|
|
|
|
// 7. (Optional) Exportiere und Importiere die Schlüssel
|
|
privateKeyPEM := exportPrivateKeyToPEM(privateKey)
|
|
fmt.Println("\nPrivate Key (PEM):\n", privateKeyPEM)
|
|
|
|
publicKeyPEM := exportPublicKeyToPEM(publicKey)
|
|
fmt.Println("\nPublic Key (PEM):\n", publicKeyPEM)
|
|
return ""
|
|
}
|
|
|
|
// Funktion, um den privaten Schlüssel in PEM-Format zu exportieren
|
|
func exportPrivateKeyToPEM(privateKey *rsa.PrivateKey) string {
|
|
privateKeyBytes := x509.MarshalPKCS1PrivateKey(privateKey)
|
|
privateKeyPEM := pem.EncodeToMemory(&pem.Block{
|
|
Type: "RSA PRIVATE KEY",
|
|
Bytes: privateKeyBytes,
|
|
})
|
|
return string(privateKeyPEM)
|
|
}
|
|
|
|
// Funktion, um den öffentlichen Schlüssel in PEM-Format zu exportieren
|
|
func exportPublicKeyToPEM(publicKey *rsa.PublicKey) string {
|
|
publicKeyBytes, err := x509.MarshalPKIXPublicKey(publicKey)
|
|
if err != nil {
|
|
log.Fatalf("Fehler beim Exportieren des öffentlichen Schlüssels: %v", err)
|
|
}
|
|
publicKeyPEM := pem.EncodeToMemory(&pem.Block{
|
|
Type: "PUBLIC KEY",
|
|
Bytes: publicKeyBytes,
|
|
})
|
|
return string(publicKeyPEM)
|
|
}
|