Lassen Sie uns einen Passwortgenerator erstellen, den wir tatsächlich verwenden können

Für unser nächstes Einsteigerprojekt bauen wir einen Passwortgenerator, der Passwörter nicht nur generiert, sondern auch verschlüsselt und speichert – damit er tatsächlich funktionsfähig ist.

Wir werden unseren Code in verschiedene Dateien aufteilen, damit am Ende keine große „main.go“-Datei entsteht.

Zuerst initialisieren wir ein Go-Projekt und erstellen eine „profile.go“-Datei, die die Logik zum Verschlüsseln und Entschlüsseln von Passwörtern enthält.

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/hex"
    "errors"
    "io"
)

// must be 32 characters 
var key = "askdjasjdbreonfsdfibsdhfgsdfhboo"

var ErrMalformedEncryption = errors.New("malformed encryption")

// password in small letters so it is not stored
type profile struct {
    Enc, Platform, password string
}

func (p *profile) encrypt() error {
    block, err := aes.NewCipher([]byte(key))
    if err != nil {
        return err
    }

    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return err
    }

    nonce := make([]byte, gcm.NonceSize())

    if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
        return err
    }

    enc := gcm.Seal(nonce, nonce, []byte(p.password), nil)
    p.Enc = hex.EncodeToString(enc)

    return nil
}

func (p *profile) decrypt() error {
    block, err := aes.NewCipher([]byte(key))
    if err != nil {
        return err
    }

    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return err
    }

    nsize := gcm.NonceSize()

    if len(p.Enc) < nsize {
        return ErrMalformedEncryption
    }

    enc, err := hex.DecodeString(p.Enc)
    if err != nil {
        return err
    }

    password, err := gcm.Open(nil, enc[:nsize], enc[nsize:], nil)
    if err != nil {
        return err
    }

    p.password = string(password)

    return nil
}

Hier erstellen wir eine Profilstruktur mit drei Feldern: Enc, Plattform und Passwort. Enc speichert das verschlüsselte Passwort, der Dienst, für den wir das Passwort generieren, wird in der Plattform gespeichert und „password“ speichert das tatsächlich generierte Passwort. Die Profilstruktur verfügt über zwei Methoden: „Verschlüsseln“ und „Entschlüsseln“. Wir verwenden AES – einen Verschlüsselungsalgorithmus mit symmetrischem Schlüssel, um unser Passwort zu verschlüsseln und zu entschlüsseln.

Als nächstes erstellen wir eine „store.go“-Datei, die die Logik zum Speichern und Abrufen von Passwörtern enthält.

package main

import (
    "encoding/gob"
    "errors"
    "os"
    "sync"
)

const filename = "profile.bin"

var (
    ErrInvalidArgs = errors.New("invalid args")
    ErrNotFound    = errors.New("not found")
)

type store struct {
    sync.RWMutex
    data map[string]*profile
}

func newStore() (*store, error) {
    s := &store{
        data: make(map[string]*profile),
    }

    if err := s.load(); err != nil {
        return nil, err
    }

    return s, nil
}

func (s *store) load() error {
    flags := os.O_CREATE | os.O_RDONLY
    f, err := os.OpenFile(filename, flags, 0644)
    if err != nil {
        return err
    }
    defer f.Close()

    info, err := f.Stat()
    if err != nil {
        return err
    }

    if info.Size() == 0 {
        return nil
    }

    return gob.NewDecoder(f).Decode(&s.data)
}

func (s *store) save() error {
    f, err := os.OpenFile(filename, os.O_WRONLY, 0644)
    if err != nil {
        return err
    }
    defer f.Close()

    return gob.NewEncoder(f).Encode(s.data)
}

func (s *store) find(platform string) (string, error) {
    s.RLock()
    defer s.RUnlock()

    p, ok := s.data[platform]
    if !ok {
        return "", ErrNotFound
    }

    if err := p.decrypt(); err != nil {
        return "", err
    }

    return p.password, nil
}

func (s *store) add(platform, password string) error {
    if platform == "" {
        return ErrInvalidArgs
    }

    p := &profile{
        Platform: platform,
        password: password,
    }

    if err := p.encrypt(); err != nil {
        return err
    }

    s.Lock()
    defer s.Unlock()

    s.data[platform] = p

    return s.save()
}

Wir haben Gob-Dateien zur Speicherung ausgewählt, da sie nicht gerade für Menschen lesbar sind. Sollte die Datei jemals offengelegt werden, sind Ihre Passwörter sicher, da sie verschlüsselt und sehr schwer zu lesen sind. Die Store-Struktur enthält Methoden zum Laden, Suchen und Speichern in der GOB-Datei. Wir speichern die Passwörter in einem Wörterbuch. Wir verwenden auch einen Mutex, um das Wörterbuch gleichzeitig sicher zu machen. Es ist wichtig zu beachten, dass wir nicht das einfach generierte Passwort speichern, sondern stattdessen seinen verschlüsselten Wert.

Jetzt schreiben wir ein paar Funktionen, die tatsächlich die Passwörter generieren. Erstellen Sie eine „password.go“-Datei und geben Sie Folgendes ein:

package main

import (
    "math"
    "math/rand"
    "slices"
    "strings"
)

const (
    half      = .5
    onethird  = .3
    onefourth = .25
)

var (
    randlowers  = randFromSeed(lowers())
    randuppers  = randFromSeed(uppers())
    randdigits  = randFromSeed(digits())
    randsymbols = randFromSeed(symbols())
)

var basicPassword = randlowers

func mediumPassword(n int) string {
    frac := math.Round(float64(n) * half)
    pwd := basicPassword(n)
    return pwd[:n-int(frac)] + randuppers(int(frac))
}

func hardPassword(n int) string {
    pwd := mediumPassword(n)
    frac := math.Round(float64(n) * onethird)
    return pwd[:n-int(frac)] + randdigits(int(frac))
}

func xhardPassword(n int) string {
    pwd := hardPassword(n)
    frac := math.Round(float64(n) * onefourth)
    return pwd[:n-int(frac)] + randsymbols(int(frac))
}

func randFromSeed(seed string) func(int) string {
    return func(n int) string {
        var b strings.Builder
        for range n {
            b.WriteByte(seed[rand.Intn(len(seed))])
        }
        return b.String()
    }
}

func lowers() string {
    var b strings.Builder
    for i := 'a'; i < 'a'+26; i++ {
        b.WriteRune(i)
    }
    return b.String()
}

func uppers() string {
    var b strings.Builder
    for i := 'A'; i < 'A'+26; i++ {
        b.WriteRune(i)
    }
    return b.String()
}

func symbols() string {
    var b strings.Builder
    for i := '!'; i < '!'+14; i++ {
        b.WriteRune(i)
    }
    for i := ':'; i < ':'+6; i++ {
        b.WriteRune(i)
    }
    for i := '['; i < '['+5; i++ {
        b.WriteRune(i)
    }
    for i := '{'; i < '{'+3; i++ {
        b.WriteRune(i)
    }
    return b.String()
}

func digits() string {
    var b strings.Builder
    for i := '0'; i < '0'+9; i++ {
        b.WriteRune(i)
    }
    return b.String()
}

func shuffle[T any](ts []T) []T {
    cloned := slices.Clone(ts)
    rand.Shuffle(len(cloned), func(i, j int) {
        cloned[i], cloned[j] = cloned[j], cloned[i]
    })
    return cloned
}

func shuffleStr(s string) string {
    return strings.Join(shuffle(strings.Split(s, "")), "")
}

Hier haben wir Funktionen geschrieben, die Passwörter mit unterschiedlichen Schwierigkeitsgraden generieren. Die Funktion „basicPassword“ generiert zufällige Zeichenfolgen aus kleinen Buchstaben. Die Funktion „mediumPassword“ übernimmt einen Bruchteil der Zeichen aus der Funktion „basicPassword“ und fügt zufällige Großbuchstaben hinzu. Die Funktion „hardPassword“ macht dasselbe für mediumPassword, fügt ihr jedoch Ziffern hinzu. Das xhardPassword macht dasselbe und fügt Symbole hinzu. Die shuffle-Funktion macht genau das, was Sie von Slices erwarten würden, während shuffleStr Strings mischt.

Jetzt lasst uns alles zusammenfügen. Erstellen Sie eine „main.go“-Datei und geben Sie Folgendes ein:

package main

import (
    "errors"
    "flag"
    "fmt"
    "log"
    "regexp"
    "strconv"
    "strings"
)

var usage = `
Usage 
-----
--get platform=[string] - Gets saved password for a platform
--set platform=[string] len=[int] level=(basic|medium|hard|xhard) - Creates and saves a password
`

var ErrUsage = errors.New(usage)

var pattern = regexp.MustCompile(`\S+=\S+`)

type level int

const (
    _ level = iota
    level_basic
    level_medium
    level_hard
    level_xhard
)

var level_key = map[string]level{
    "basic":  level_basic,
    "medium": level_medium,
    "hard":   level_hard,
    "xhard":  level_xhard,
}

type commands struct {
    get, set bool
}

func createCommands() (c commands) {
    flag.BoolVar(&c.get, "get", false, "get password for platform")
    flag.BoolVar(&c.set, "set", false, "set password for platform")
    flag.Parse()
    return
}

func (c commands) exec(store *store) (string, error) {
    switch {
    case c.get:
        return c.getPassword(store)
    case c.set:
        return c.setPassword(store)
    default:
        return "", ErrUsage
    }
}

func (c commands) getPassword(store *store) (string, error) {
    params, err := c.parse()
    if err != nil {
        return "", err
    }

    return store.find(params["platform"])
}

func (c commands) setPassword(store *store) (string, error) {
    params, err := c.parse()
    if err != nil {
        return "", err
    }

    var password string

    n, err := strconv.Atoi(params["len"])
    if err != nil {
        return "", err
    }

    if n < 8 {
        return "", fmt.Errorf("password len cannot be less than 8")
    }

    switch level_key[params["level"]] {
    case level_basic:
        password = basicPassword(n)
    case level_medium:
        password = mediumPassword(n)
    case level_hard:
        password = hardPassword(n)
    case level_xhard:
        password = xhardPassword(n)
    default:
        return "", ErrUsage
    }

    password = shuffleStr(password)

    if err := store.add(params["platform"], password); err != nil {
        return "", err
    }

    return password, nil
}

func (c commands) parse() (map[string]string, error) {
    args := flag.Args()

    if len(args) == 0 {
        return nil, ErrUsage
    }

    params := make(map[string]string)

    for i := range args {
        if !pattern.MatchString(args[i]) {
            return nil, ErrUsage
        }

        parts := strings.Split(args[i], "=")
        params[parts[0]] = parts[1]
    }

    return params, nil
}

func main() {
    store, err := newStore()
    if err != nil {
        log.Fatalf("could not initialize store: %v", err)
    }

    c := createCommands()

    password, err := c.exec(store)
    if err != nil {
        log.Fatalf("could not execute flag commands: %v", err)
    }

    fmt.Printf("password: %s\n", password)
}

Wir haben Flags verwendet, um anzugeben, wie wir das Verhalten der Anwendung erwarten. „--get“, um ein Passwort zu erhalten, und „--set“, um ein Passwort zu generieren und zu speichern. Um ein Passwort festzulegen, stellt der Benutzer Argumente mit den Flags bereit, um die Anwendung über den Typ des zu generierenden und zu speichernden Passworts zu informieren. Um ein Passwort zu erhalten, stellt der Benutzer auch Argumente bereit, um das abzurufende Passwort anzugeben.

Sie können jetzt „go build“ ausführen, um eine Binärdatei zu erstellen und die Anwendung zu testen.

Das obige ist der detaillierte Inhalt vonLassen Sie uns einen Passwortgenerator erstellen, den wir tatsächlich verwenden können. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!