


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) <p>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. </p> <p>Als nächstes erstellen wir eine „store.go“-Datei, die die Logik zum Speichern und Abrufen von Passwörtern enthält.<br> </p> <pre class="brush:php;toolbar:false">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 <p>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.</p> <p>Jetzt lasst uns alles zusammenfügen. Erstellen Sie eine „main.go“-Datei und geben Sie Folgendes ein:<br> </p> <pre class="brush:php;toolbar:false">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 <p>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.</p> <p>Sie können jetzt „go build“ ausführen, um eine Binärdatei zu erstellen und die Anwendung zu testen.</p> <p><img src="/static/imghwm/default1.png" data-src="https://img.php.cn/upload/article/000/000/000/173158638678335.jpg?x-oss-process=image/resize,p_40" class="lazy" alt="Let"></p>
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!

GoisidealforbuildingsCalablesSystemsDuetoitsSimplicity, Effizienz und verblüfftem Inconcurrencysupport.1) Go'ScleanSyNtaxandminimalisticDeInenHanceProductivity und ReduzienEirrors.2) ItsgoroutinesandchannelsableCrentCrent-Programme, Distrioutines und ChannelenableCrent-Programme, DistributingworkloNecrent-Programme,

Initunctionsingorunautomatischbeforemain () und sarEsfulForsSetingupenvironmentsandinitializingVariables

GoinitializespackagesintheordertheyareImported, SheexecuteStfunctionSwitHinapackageInredeDinitionorder und FileNamesDeterminetheorderacrossmultipleFiles

CustomInterFacesingoarecrucialForwritingFlexible, Wartelable und testableCode

Der Grund für die Verwendung von Schnittstellen für Simulation und Test ist, dass die Schnittstelle die Definition von Verträgen ohne Angabe von Implementierungen ermöglicht, wodurch die Tests isolierter und einfacher werden. 1) Die implizite Implementierung der Schnittstelle erleichtert es einfach, Scheinobjekte zu erstellen, die reale Implementierungen bei den Tests ersetzen können. 2) Die Verwendung von Schnittstellen kann die tatsächliche Implementierung des Dienstes in Unit -Tests problemlos ersetzen und die Komplexität und die Zeit der Tests reduzieren. 3) Die von der Schnittstelle bereitgestellte Flexibilität ermöglicht Änderungen des simulierten Verhaltens für verschiedene Testfälle. 4) Schnittstellen helfen von Anfang an, Testable -Code zu entwerfen und die Modularität und Wartbarkeit des Codes zu verbessern.

In Go wird die Init -Funktion für die Paketinitialisierung verwendet. 1) Die Init -Funktion wird automatisch bei der Paketinitialisierung aufgerufen und ist geeignet, um globale Variablen zu initialisieren, Verbindungen zu setzen und Konfigurationsdateien zu laden. 2) Es kann mehrere Init -Funktionen geben, die in Dateireihenfolge ausgeführt werden können. 3) Bei der Verwendung sollten die Ausführungsreihenfolge, die Testschwierigkeit und die Leistungsauswirkungen in Betracht gezogen werden. 4) Es wird empfohlen, Nebenwirkungen zu reduzieren, die Abhängigkeitsinjektion zu verwenden und die Initialisierung zu verzögern, um die Verwendung von Init -Funktionen zu optimieren.

GO'SSelectstatementsTreamlinesConcurrentProgrammingByMultiplexingoperationen.1) ITallowswaitingonMultiPhanneloperationen, ExecutingTheFirstreadyone) TheDefaultCasepreventsDeadlocksByAntheProgramtoprosectroseverifnooperation.3) itcanpeusedefoursend

Contextandwaitgroupsarecrucialingoforminggoroutineseffektiv.1) contextAllowSsignalingCancellationanddeadlinesAcrossapiobears, Sicherstellung von Goroutinescanbesten


Heiße KI -Werkzeuge

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool
Ausziehbilder kostenlos

Clothoff.io
KI-Kleiderentferner

Video Face Swap
Tauschen Sie Gesichter in jedem Video mühelos mit unserem völlig kostenlosen KI-Gesichtstausch-Tool aus!

Heißer Artikel

Heiße Werkzeuge

SublimeText3 Englische Version
Empfohlen: Win-Version, unterstützt Code-Eingabeaufforderungen!

ZendStudio 13.5.1 Mac
Leistungsstarke integrierte PHP-Entwicklungsumgebung

MinGW – Minimalistisches GNU für Windows
Dieses Projekt wird derzeit auf osdn.net/projects/mingw migriert. Sie können uns dort weiterhin folgen. MinGW: Eine native Windows-Portierung der GNU Compiler Collection (GCC), frei verteilbare Importbibliotheken und Header-Dateien zum Erstellen nativer Windows-Anwendungen, einschließlich Erweiterungen der MSVC-Laufzeit zur Unterstützung der C99-Funktionalität. Die gesamte MinGW-Software kann auf 64-Bit-Windows-Plattformen ausgeführt werden.

SAP NetWeaver Server-Adapter für Eclipse
Integrieren Sie Eclipse mit dem SAP NetWeaver-Anwendungsserver.

Herunterladen der Mac-Version des Atom-Editors
Der beliebteste Open-Source-Editor
