smartpasslib-go ^v4.0.0

• Zero-Storage Security — no passwords or secret phrases are ever stored or transmitted
• Decentralized Architecture — no central servers, no cloud dependency
• Cross-Platform Deterministic Generation — identical secret + parameters = identical password on any language
• Metadata Only — store only verification metadata (public keys, descriptions, lengths)
• On-Demand Regeneration — passwords are recalculated when needed
• Cryptographically Secure — uses crypto/rand and SHA-256

• Decentralized & Serverless — no central database, no cloud lock-in
• Smart Password Generation — deterministic from secret phrase
• Public/Private Key System — 15-30 iterations for private key, 45-60 for public key
• Secret Verification — verify secret without exposing it
• Random Password Generation — cryptographically secure random passwords
• Authentication Codes — short codes for 2FA/MFA (4-100 chars)
• No External Dependencies — pure Go, uses standard crypto

• Proof of Knowledge — public keys verify secrets without exposing them
• Decentralized Trust — no third party needed
• Deterministic Security — same input = same output, always reproducible across platforms
• Dynamic Iteration Counts — private key: 15-30, public key: 45-60
• Zero Storage of Secrets — secret phrases exist only in your memory
• No Recovery Backdoors — lost secret = permanently lost passwords

Validation Rules: Secret phrase: min 12 chars · Password length: 12-100 chars · Code: 4-100 chars

Key derivation (same as Python/JS/Kotlin/C# versions v4.0.0):

Character Set:

!@#$%^&*()_+-=[]{};:,.<>?/ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz

Decentralized Architecture:

• No central authority required
• Metadata can be synced via any channel (USB, cloud, even paper)
• Your security depends only on your secret phrase
• Works offline — no internet connection required

go get github.com/smartlegionlab/smartpasslib-go@v4.0.0

Generate Smart Password:

package main

import (
    "fmt"
    "github.com/smartlegionlab/smartpasslib-go"
)

func main() {
    secret := "MyStrongSecretPhrase2026!"
    length := 16

    password, _ := smartpasslib.GenerateSmartPassword(secret, length)
    fmt.Println(password)
}

Generate Public/Private Keys:

secret := "MyStrongSecretPhrase2026!"

publicKey, _ := smartpasslib.GeneratePublicKey(secret)
privateKey, _ := smartpasslib.GeneratePrivateKey(secret)

fmt.Println("Public Key (store locally):", publicKey)
fmt.Println("Private Key (never store):", privateKey)

Verify Secret Against Public Key:

secret := "MyStrongSecretPhrase2026!"
storedPublicKey := "..." // from local

isValid, _ := smartpasslib.VerifySecret(secret, storedPublicKey)
if isValid {
    password, _ := smartpasslib.GenerateSmartPassword(secret, 16)
}

Generate Random Passwords:

// Strong random (cryptographically secure)
strong, _ := smartpasslib.GenerateStrongPassword(20)

// Base random
base, _ := smartpasslib.GenerateBasePassword(16)

// Authentication code (4-100 chars)
code, _ := smartpasslib.GenerateCode(8)

Constants:

Functions:

Input Validation:

Secret Phrase Requirements:

• Minimum 12 characters (enforced)
• Case-sensitive
• Use mix of: uppercase, lowercase, numbers, symbols
• Never store digitally
• NEVER use your password description as secret phrase

Strong Secret Examples:

✅ "MyStrongSecretPhrase2026!"   — mixed case + numbers + symbols
✅ "P@ssw0rd!LongSecret"         — special chars + numbers + length
✅ "GitHubPersonal2026!"         — description + extra chars

Weak Secret Examples (avoid):

❌ "short"                       — too short, returns error
❌ "GitHub Account"              — using description as secret (weak!)
❌ "password"                    — dictionary word, too short
❌ "1234567890"                  — only digits, too short

Decentralized Nature:

There is no "forgot password" button. This is by design:

• No central server can reset your passwords
• No support team can recover your access
• Your secret phrase is the ONLY key

This is the price of true decentralization — you are completely in control.

• Pointer-Based Security Paradigm — 10.5281/zenodo.17204738
  Architectural Shift from Data Protection to Data Non-Existence
• Local Data Regeneration Paradigm — 10.5281/zenodo.17264327
  Ontological Shift from Data Transmission to Synchronous State Discovery

Same deterministic algorithm is available in multiple languages:

• smartpasslib — Python
• smartpasslib-js — JavaScript
• smartpasslib-kotlin — Kotlin
• smartpasslib-csharp — C#

Install Go:

# Arch Linux
sudo pacman -S go

# Ubuntu/Debian
sudo apt install golang

Run tests:

go test -v

By using this software, you agree to the full disclaimer terms.

Software provided "AS IS" without warranty. You assume all risks.

Full legal disclaimer: See DISCLAIMER.md

License: BSD 3-Clause License