실제로 사용할 수 있는 비밀번호 생성기를 만들어 보겠습니다.

다음 초보자 프로젝트에서는 비밀번호를 생성할 뿐만 아니라 비밀번호를 암호화하고 저장하여 실제로 작동하는 비밀번호 생성기를 구축할 것입니다.

큰 "main.go" 파일이 되지 않도록 코드를 여러 파일로 분할할 예정입니다.

먼저 go 프로젝트를 초기화하고 비밀번호 암호화 및 복호화 로직이 포함될 "profile.go" 파일을 생성합니다.

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
}

여기서 Enc, Platform 및 Password의 3개 필드가 있는 프로필 구조를 만듭니다. Enc는 암호화된 비밀번호를 보유하고, 비밀번호를 생성하는 서비스는 플랫폼에 저장되며 비밀번호는 실제 생성된 비밀번호를 보유합니다. 프로필 구조에는 "암호화"와 "해독"의 두 가지 방법이 있습니다. 우리는 대칭 키 암호화 알고리즘인 AES를 사용하여 비밀번호를 암호화하고 해독합니다.

다음으로 비밀번호 저장 및 검색 논리가 포함된 "store.go" 파일을 만듭니다.

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()
}

우리는 사람이 읽을 수 없는 gob 파일을 저장용으로 선택했습니다. 파일이 노출되더라도 비밀번호는 암호화되어 읽기 어렵기 때문에 안전합니다. store 구조체에는 gob 파일을 로드하고 찾고 저장하는 방법이 포함되어 있습니다. 우리는 사전에 비밀번호를 저장합니다. 또한 사전을 동시에 안전하게 만들기 위해 뮤텍스를 사용합니다. 중요한 점은 일반 생성된 비밀번호를 저장하지 않고 대신 암호화된 값을 저장한다는 것입니다.

이제 실제로 비밀번호를 생성하는 몇 가지 함수를 작성해 보겠습니다. "password.go" 파일을 생성하고 다음을 입력하세요

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, "")), "")
}

여기에는 다양한 난이도에서 비밀번호를 생성하는 기능이 작성되어 있습니다. basicPassword 함수는 임의의 소문자 문자열을 생성합니다. MediumPassword 함수는 basicPassword 함수에서 일부 문자를 가져와서 임의의 대문자를 추가합니다. hardPassword 함수는 MediumPassword에 대해 동일한 작업을 수행하지만 여기에 숫자를 추가합니다. xhardPassword는 동일한 작업을 수행하고 기호를 추가합니다. shuffleStr이 문자열을 섞는 동안 shuffle 기능은 슬라이스에서 기대하는 것과 정확히 일치합니다.

이제 모든 것을 종합해 보겠습니다. "main.go" 파일을 생성하고 다음을 입력하세요

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)
}

우리는 플래그를 사용하여 애플리케이션이 어떻게 작동할지를 지정했습니다. "--get"은 비밀번호를 가져오고 "--set"은 비밀번호를 생성하고 저장합니다. 비밀번호를 설정하기 위해 사용자는 생성하고 저장할 비밀번호 유형을 애플리케이션에 지시하는 플래그와 함께 인수를 제공합니다. 비밀번호를 얻기 위해 사용자는 검색할 비밀번호를 지정하는 인수도 제공합니다.

이제 "go build"를 실행하여 바이너리를 빌드하고 애플리케이션을 테스트할 수 있습니다.

위 내용은 실제로 사용할 수 있는 비밀번호 생성기를 만들어 보겠습니다.의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!