Building 70 Projects ranging from beginner to advanced so anyone can — learn from, build upon, use as a reference, or even copy directly. Owned by my cybersecurity company đŸ‘‡
Go aicertificationcloud-engineeringcybercybersecuritycybersecurity-analystcybersecurity-certificationcybersecurity-certificationscybersecurity-educationcybersecurity-jobscybersecurity-portfoliocybersecurity-projectscybersecurity-toolsgrchackinglearningpentestingproject-repositoryprojetcspython
feat(crypha): scaffold steganography multi-tool with payload engine (M0-M1)
CarterPerez-devb89b57347dba
diff --git a/PROJECTS/beginner/steganography-multi-tool/.gitignore b/PROJECTS/beginner/steganography-multi-tool/.gitignorenew file mode 100644index 00000000..2ab2b026--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/.gitignore@@ -0,0 +1,17 @@+# build output+/dist/+/crypha++# test / coverage+coverage.out+*.test+*.prof++# local dev docs (research / plans / context stay local)+/docs/++# editor / os+.idea/+.vscode/+*.swp+.DS_Storediff --git a/PROJECTS/beginner/steganography-multi-tool/.golangci.yml b/PROJECTS/beginner/steganography-multi-tool/.golangci.ymlnew file mode 100644index 00000000..0d61cf12--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/.golangci.yml@@ -0,0 +1,32 @@+# ©AngelaMos | 2026+# .golangci.yml++version: "2"++run:+ timeout: 5m++linters:+ enable:+ - errcheck+ - govet+ - ineffassign+ - staticcheck+ - unused+ - misspell+ - unconvert+ - bodyclose+ - gosec+ settings:+ gosec:+ excludes:+ - G115++formatters:+ enable:+ - gofmt+ - goimports++issues:+ max-issues-per-linter: 0+ max-same-issues: 0diff --git a/PROJECTS/beginner/steganography-multi-tool/cmd/crypha/main.go b/PROJECTS/beginner/steganography-multi-tool/cmd/crypha/main.gonew file mode 100644index 00000000..c639ef1c--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/cmd/crypha/main.go@@ -0,0 +1,14 @@+/*+©AngelaMos | 2026+main.go++Entry point for the crypha steganography multi-tool+*/++package main++import "github.com/CarterPerez-dev/crypha/internal/cli"++func main() {+ cli.Execute()+}diff --git a/PROJECTS/beginner/steganography-multi-tool/go.mod b/PROJECTS/beginner/steganography-multi-tool/go.modnew file mode 100644index 00000000..fa9968d3--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/go.mod@@ -0,0 +1,14 @@+module github.com/CarterPerez-dev/crypha++go 1.25.0++require (+ github.com/spf13/cobra v1.10.2+ golang.org/x/crypto v0.52.0+)++require (+ github.com/inconshreveable/mousetrap v1.1.0 // indirect+ github.com/spf13/pflag v1.0.9 // indirect+ golang.org/x/sys v0.47.0 // indirect+)diff --git a/PROJECTS/beginner/steganography-multi-tool/go.sum b/PROJECTS/beginner/steganography-multi-tool/go.sumnew file mode 100644index 00000000..666fe98d--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/go.sum@@ -0,0 +1,14 @@+github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=+github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=+github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=+github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=+github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=+go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=+golang.org/x/crypto v0.52.0 h1:RMs7fP2rXdep0CftQlK8Uf+kibLm7qkCcradZWYz988=+golang.org/x/crypto v0.52.0/go.mod h1:1QgfPxDqh0T2M/elOJtp9RvuR95kVjir0e6/BvEmGbc=+golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=+golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/bitio/bitio.go b/PROJECTS/beginner/steganography-multi-tool/internal/bitio/bitio.gonew file mode 100644index 00000000..398c1b8e--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/internal/bitio/bitio.go@@ -0,0 +1,69 @@+/*+©AngelaMos | 2026+bitio.go++MSB-first bit reader and writer for carriers that embed data bit by bit+*/++package bitio++import "io"++type Reader struct {+ in []byte+ pos int+}++func NewReader(b []byte) *Reader {+ return &Reader{in: b}+}++func (r *Reader) ReadBit() (byte, error) {+ if r.pos >= len(r.in)*8 {+ return 0, io.EOF+ }+ byteIdx := r.pos / 8+ bitIdx := 7 - (r.pos % 8)+ bit := (r.in[byteIdx] >> bitIdx) & 1+ r.pos+++ return bit, nil+}++func (r *Reader) TotalBits() int {+ return len(r.in) * 8+}++func (r *Reader) Remaining() int {+ return len(r.in)*8 - r.pos+}++type Writer struct {+ out []byte+ cur byte+ fill int+}++func NewWriter() *Writer {+ return &Writer{}+}++func (w *Writer) WriteBit(bit byte) {+ w.cur = (w.cur << 1) | (bit & 1)+ w.fill+++ if w.fill == 8 {+ w.out = append(w.out, w.cur)+ w.cur = 0+ w.fill = 0+ }+}++func (w *Writer) Bytes() []byte {+ if w.fill == 0 {+ return w.out+ }+ return append(w.out, w.cur<<(8-w.fill))+}++func (w *Writer) BitsWritten() int {+ return len(w.out)*8 + w.fill+}diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/bitio/bitio_test.go b/PROJECTS/beginner/steganography-multi-tool/internal/bitio/bitio_test.gonew file mode 100644index 00000000..64999062--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/internal/bitio/bitio_test.go@@ -0,0 +1,82 @@+/*+©AngelaMos | 2026+bitio_test.go++Round-trip and boundary tests for the MSB-first bit reader and writer+*/++package bitio++import (+ "bytes"+ "io"+ "testing"+)++func TestRoundTripByteAligned(t *testing.T) {+ cases := [][]byte{+ {},+ {0x00},+ {0xFF},+ {0xA5, 0x5A, 0x00, 0xFF, 0x0F, 0xF0},+ []byte("crypha carries the secret"),+ }+ for _, in := range cases {+ r := NewReader(in)+ w := NewWriter()+ for {+ bit, err := r.ReadBit()+ if err == io.EOF {+ break+ }+ if err != nil {+ t.Fatalf("ReadBit: %v", err)+ }+ w.WriteBit(bit)+ }+ if got := w.Bytes(); !bytes.Equal(got, in) {+ t.Errorf("round-trip mismatch: got %x want %x", got, in)+ }+ }+}++func TestMSBFirstOrder(t *testing.T) {+ r := NewReader([]byte{0b10000001})+ want := []byte{1, 0, 0, 0, 0, 0, 0, 1}+ for i, wbit := range want {+ got, err := r.ReadBit()+ if err != nil {+ t.Fatalf("bit %d: %v", i, err)+ }+ if got != wbit {+ t.Errorf("bit %d: got %d want %d", i, got, wbit)+ }+ }+}++func TestReaderCounters(t *testing.T) {+ r := NewReader([]byte{0x00, 0x00})+ if r.TotalBits() != 16 {+ t.Fatalf("TotalBits: got %d want 16", r.TotalBits())+ }+ if _, err := r.ReadBit(); err != nil {+ t.Fatal(err)+ }+ if r.Remaining() != 15 {+ t.Errorf("Remaining: got %d want 15", r.Remaining())+ }+}++func TestWriterPadsPartialByte(t *testing.T) {+ w := NewWriter()+ w.WriteBit(1)+ w.WriteBit(1)+ w.WriteBit(1)+ if w.BitsWritten() != 3 {+ t.Fatalf("BitsWritten: got %d want 3", w.BitsWritten())+ }+ got := w.Bytes()+ if len(got) != 1 || got[0] != 0b11100000 {+ t.Errorf("partial byte: got %08b want 11100000", got[0])+ }+}diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/carrier/carrier.go b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/carrier.gonew file mode 100644index 00000000..a1b829a2--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/carrier.go@@ -0,0 +1,67 @@+/*+©AngelaMos | 2026+carrier.go++The Carrier interface and self-registering registry that every format plugs into+*/++package carrier++import (+ "io"+ "sort"+)++type Carrier interface {+ Format() string+ Hide(cover io.Reader, payload []byte, out io.Writer) error+ Reveal(stego io.Reader) ([]byte, error)+ Capacity(cover io.Reader) (int, error)+ Sniff(stego io.ReadSeeker) bool+}++var registry = map[string]Carrier{}++func Register(c Carrier) {+ registry[c.Format()] = c+}++func Get(name string) (Carrier, bool) {+ c, ok := registry[name]+ return c, ok+}++func All() []Carrier {+ out := make([]Carrier, 0, len(registry))+ for _, c := range registry {+ out = append(out, c)+ }+ sort.Slice(out, func(i, j int) bool {+ return out[i].Format() < out[j].Format()+ })+ return out+}++func Formats() []string {+ out := make([]string, 0, len(registry))+ for name := range registry {+ out = append(out, name)+ }+ sort.Strings(out)+ return out+}++func Detect(stego io.ReadSeeker) (Carrier, bool) {+ for _, c := range All() {+ if _, err := stego.Seek(0, io.SeekStart); err != nil {+ return nil, false+ }+ if c.Sniff(stego) {+ if _, err := stego.Seek(0, io.SeekStart); err != nil {+ return nil, false+ }+ return c, true+ }+ }+ return nil, false+}diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/carrier/carrier_test.go b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/carrier_test.gonew file mode 100644index 00000000..a435e00e--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/carrier_test.go@@ -0,0 +1,73 @@+/*+©AngelaMos | 2026+carrier_test.go++Registry behaviour tests using fake carriers+*/++package carrier++import (+ "bytes"+ "io"+ "testing"+)++type fakeCarrier struct {+ format string+ magic byte+}++func (f fakeCarrier) Format() string { return f.format }++func (f fakeCarrier) Hide(_ io.Reader, _ []byte, _ io.Writer) error { return nil }++func (f fakeCarrier) Reveal(_ io.Reader) ([]byte, error) { return nil, nil }++func (f fakeCarrier) Capacity(_ io.Reader) (int, error) { return 0, nil }++func (f fakeCarrier) Sniff(stego io.ReadSeeker) bool {+ head := make([]byte, 1)+ if _, err := io.ReadFull(stego, head); err != nil {+ return false+ }+ return head[0] == f.magic+}++func TestRegisterGetFormats(t *testing.T) {+ registry = map[string]Carrier{}+ Register(fakeCarrier{format: "zeta", magic: 0x01})+ Register(fakeCarrier{format: "alpha", magic: 0x02})++ if _, ok := Get("alpha"); !ok {+ t.Fatal("expected alpha to be registered")+ }+ if _, ok := Get("missing"); ok {+ t.Fatal("did not expect missing to resolve")+ }++ got := Formats()+ if len(got) != 2 || got[0] != "alpha" || got[1] != "zeta" {+ t.Errorf("Formats not sorted: %v", got)+ }+ if all := All(); len(all) != 2 || all[0].Format() != "alpha" {+ t.Errorf("All not sorted: %v", all)+ }+}++func TestDetect(t *testing.T) {+ registry = map[string]Carrier{}+ Register(fakeCarrier{format: "alpha", magic: 0x02})+ Register(fakeCarrier{format: "beta", magic: 0x03})++ stego := bytes.NewReader([]byte{0x03, 0xFF, 0xEE})+ c, ok := Detect(stego)+ if !ok || c.Format() != "beta" {+ t.Fatalf("Detect: got %v ok=%v want beta", c, ok)+ }++ none := bytes.NewReader([]byte{0x99})+ if _, ok := Detect(none); ok {+ t.Error("expected no match for unknown magic")+ }+}diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/cli/root.go b/PROJECTS/beginner/steganography-multi-tool/internal/cli/root.gonew file mode 100644index 00000000..07885afb--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/internal/cli/root.go@@ -0,0 +1,34 @@+/*+©AngelaMos | 2026+root.go++Cobra root command and CLI entry wiring for crypha+*/++package cli++import (+ "fmt"+ "os"++ "github.com/CarterPerez-dev/crypha/internal/config"+ "github.com/spf13/cobra"+)++var rootCmd = &cobra.Command{+ Use: config.BinaryName,+ Short: config.ShortDescription,+ Long: config.LongDescription,+ Version: config.Version,+}++func Execute() {+ if err := rootCmd.Execute(); err != nil {+ fmt.Fprintln(os.Stderr, err)+ os.Exit(1)+ }+}++func init() {+ rootCmd.SetVersionTemplate(config.BinaryName + " {{.Version}}\n")+}diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/config/config.go b/PROJECTS/beginner/steganography-multi-tool/internal/config/config.gonew file mode 100644index 00000000..ba5c5af3--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/internal/config/config.go@@ -0,0 +1,17 @@+/*+©AngelaMos | 2026+config.go++Central constants for crypha so no magic numbers or strings live elsewhere+*/++package config++const (+ BinaryName = "crypha"+ Version = "0.1.0"+ ShortDescription = "Multi-format steganography for images, audio, QR, text, and PDFs"+ LongDescription = "crypha hides an encrypted payload inside five carrier types " ++ "(image, audio, QR, zero-width text, PDF) and extracts it back, " ++ "from a scriptable CLI or an interactive TUI."+)diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/payload/compress.go b/PROJECTS/beginner/steganography-multi-tool/internal/payload/compress.gonew file mode 100644index 00000000..eab0ac0f--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/internal/payload/compress.go@@ -0,0 +1,35 @@+/*+©AngelaMos | 2026+compress.go++Optional flate compression applied before encryption in the payload envelope+*/++package payload++import (+ "bytes"+ "compress/flate"+ "io"+)++func compress(data []byte) ([]byte, error) {+ var buf bytes.Buffer+ w, err := flate.NewWriter(&buf, flate.BestCompression)+ if err != nil {+ return nil, err+ }+ if _, err := w.Write(data); err != nil {+ return nil, err+ }+ if err := w.Close(); err != nil {+ return nil, err+ }+ return buf.Bytes(), nil+}++func decompress(data []byte) ([]byte, error) {+ r := flate.NewReader(bytes.NewReader(data))+ defer func() { _ = r.Close() }()+ return io.ReadAll(r)+}diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/payload/crypto.go b/PROJECTS/beginner/steganography-multi-tool/internal/payload/crypto.gonew file mode 100644index 00000000..8c55e248--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/internal/payload/crypto.go@@ -0,0 +1,75 @@+/*+©AngelaMos | 2026+crypto.go++Argon2id key derivation and AEAD selection for the payload envelope+*/++package payload++import (+ "crypto/aes"+ "crypto/cipher"++ "golang.org/x/crypto/argon2"+ "golang.org/x/crypto/chacha20poly1305"+)++type kdfParams struct {+ time uint32+ memory uint32+ threads uint8+}++func paramsForStrength(s Strength) kdfParams {+ if s == StrengthHigh {+ return kdfParams{time: argonHighTime, memory: argonHighMemory, threads: argonThreads}+ }+ return kdfParams{time: argonDefaultTime, memory: argonDefaultMemory, threads: argonThreads}+}++func (p kdfParams) valid() bool {+ if p.threads == 0 || p.time == 0 {+ return false+ }+ if p.memory > argonMaxMemory {+ return false+ }+ return p.memory >= 8*uint32(p.threads)+}++func deriveKey(passphrase, salt []byte, p kdfParams) []byte {+ return argon2.IDKey(passphrase, salt, p.time, p.memory, p.threads, keyLen)+}++func newAEAD(c Cipher, key []byte) (cipher.AEAD, byte, error) {+ switch c {+ case CipherAES256GCM:+ aead, err := gcm(key)+ return aead, cipherIDAES256GCM, err+ case CipherChaCha20, "":+ aead, err := chacha20poly1305.New(key)+ return aead, cipherIDChaCha20, err+ default:+ return nil, 0, ErrUnknownCipher+ }+}++func aeadByID(id byte, key []byte) (cipher.AEAD, error) {+ switch id {+ case cipherIDAES256GCM:+ return gcm(key)+ case cipherIDChaCha20:+ return chacha20poly1305.New(key)+ default:+ return nil, ErrUnknownCipher+ }+}++func gcm(key []byte) (cipher.AEAD, error) {+ block, err := aes.NewCipher(key)+ if err != nil {+ return nil, err+ }+ return cipher.NewGCM(block)+}diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/payload/envelope.go b/PROJECTS/beginner/steganography-multi-tool/internal/payload/envelope.gonew file mode 100644index 00000000..77bc466d--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/internal/payload/envelope.go@@ -0,0 +1,202 @@+/*+©AngelaMos | 2026+envelope.go++Pack and unpack the crypha payload envelope++Layout: magic(4) ver(1) flags(1) [cipher(1) params(9) salt(16) nonce(12) if encrypted]+ len(4) body(N) crc32(4). The header up to nonce is the AEAD additional data.+*/++package payload++import (+ "bytes"+ "crypto/rand"+ "encoding/binary"+ "hash/crc32"+)++func Pack(data []byte, opts Options) ([]byte, error) {+ if len(data) == 0 {+ return nil, ErrEmptyPayload+ }++ var flags byte+ body := data++ if opts.Compress {+ c, err := compress(body)+ if err != nil {+ return nil, err+ }+ body = c+ flags |= flagCompressed+ }++ header := new(bytes.Buffer)+ header.Write(magic[:])+ header.WriteByte(currentVersion)++ if len(opts.Passphrase) > 0 {+ flags |= flagEncrypted+ header.WriteByte(flags)++ salt := make([]byte, saltLen)+ if _, err := rand.Read(salt); err != nil {+ return nil, err+ }+ params := paramsForStrength(opts.Strength)+ key := deriveKey(opts.Passphrase, salt, params)+ aead, cipherID, err := newAEAD(opts.Cipher, key)+ if err != nil {+ return nil, err+ }+ nonce := make([]byte, aead.NonceSize())+ if _, err := rand.Read(nonce); err != nil {+ return nil, err+ }++ header.WriteByte(cipherID)+ var pbuf [paramsLen]byte+ binary.BigEndian.PutUint32(pbuf[0:4], params.time)+ binary.BigEndian.PutUint32(pbuf[4:8], params.memory)+ pbuf[8] = params.threads+ header.Write(pbuf[:])+ header.Write(salt)+ header.Write(nonce)++ body = aead.Seal(nil, nonce, body, header.Bytes())+ } else {+ header.WriteByte(flags)+ }++ out := new(bytes.Buffer)+ out.Write(header.Bytes())+ var meta [lenField]byte+ binary.BigEndian.PutUint32(meta[:], uint32(len(body)))+ out.Write(meta[:])+ out.Write(body)+ binary.BigEndian.PutUint32(meta[:], crc32.ChecksumIEEE(body))+ out.Write(meta[:])++ return out.Bytes(), nil+}++type parsed struct {+ flags byte+ aad []byte+ cipherID byte+ params kdfParams+ salt []byte+ nonce []byte+ body []byte+}++func parse(env []byte) (*parsed, error) {+ off := 0+ remaining := func(n int) bool { return off+n <= len(env) }++ if !remaining(len(magic)) || !bytes.Equal(env[0:len(magic)], magic[:]) {+ return nil, ErrBadMagic+ }+ off = len(magic)++ if !remaining(1) {+ return nil, ErrTruncated+ }+ if env[off] != currentVersion {+ return nil, ErrUnsupportedVersion+ }+ off++++ if !remaining(1) {+ return nil, ErrTruncated+ }+ p := &parsed{flags: env[off]}+ off++++ if p.flags&flagEncrypted != 0 {+ if !remaining(1 + paramsLen + saltLen + nonceLen) {+ return nil, ErrTruncated+ }+ p.cipherID = env[off]+ off+++ p.params = kdfParams{+ time: binary.BigEndian.Uint32(env[off : off+4]),+ memory: binary.BigEndian.Uint32(env[off+4 : off+8]),+ threads: env[off+8],+ }+ off += paramsLen+ if !p.params.valid() {+ return nil, ErrBadParams+ }+ p.salt = env[off : off+saltLen]+ off += saltLen+ p.nonce = env[off : off+nonceLen]+ off += nonceLen+ p.aad = env[0:off]+ }++ if !remaining(lenField) {+ return nil, ErrTruncated+ }+ bodyLen := int(binary.BigEndian.Uint32(env[off : off+lenField]))+ off += lenField+ if bodyLen < 0 || !remaining(bodyLen) {+ return nil, ErrTruncated+ }+ p.body = env[off : off+bodyLen]+ off += bodyLen++ if !remaining(crcField) {+ return nil, ErrTruncated+ }+ if crc32.ChecksumIEEE(p.body) != binary.BigEndian.Uint32(env[off:off+crcField]) {+ return nil, ErrChecksumMismatch+ }++ return p, nil+}++func Unpack(env, passphrase []byte) ([]byte, error) {+ p, err := parse(env)+ if err != nil {+ return nil, err+ }++ body := p.body+ if p.flags&flagEncrypted != 0 {+ if len(passphrase) == 0 {+ return nil, ErrPassphraseRequired+ }+ key := deriveKey(passphrase, p.salt, p.params)+ aead, err := aeadByID(p.cipherID, key)+ if err != nil {+ return nil, err+ }+ plain, err := aead.Open(nil, p.nonce, body, p.aad)+ if err != nil {+ return nil, ErrDecrypt+ }+ body = plain+ }++ if p.flags&flagCompressed != 0 {+ return decompress(body)+ }+ return body, nil+}++func Validate(env []byte) error {+ _, err := parse(env)+ return err+}++func IsEncrypted(env []byte) (bool, error) {+ p, err := parse(env)+ if err != nil {+ return false, err+ }+ return p.flags&flagEncrypted != 0, nil+}diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/payload/envelope_test.go b/PROJECTS/beginner/steganography-multi-tool/internal/payload/envelope_test.gonew file mode 100644index 00000000..7b94845e--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/internal/payload/envelope_test.go@@ -0,0 +1,158 @@+/*+©AngelaMos | 2026+envelope_test.go++Round-trip, integrity, and hardening tests for the payload envelope+*/++package payload++import (+ "bytes"+ "errors"+ "testing"+)++var secret = []byte("the eagle lands at midnight -- coordinates 41.40N 2.17E")++func TestRoundTrip(t *testing.T) {+ pass := []byte("correct horse battery staple")+ cases := []struct {+ name string+ opts Options+ }{+ {"plain", Options{}},+ {"compressed", Options{Compress: true}},+ {"encrypted-chacha", Options{Passphrase: pass}},+ {"encrypted-aes", Options{Passphrase: pass, Cipher: CipherAES256GCM}},+ {"encrypted-compressed", Options{Passphrase: pass, Compress: true}},+ }+ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ env, err := Pack(secret, tc.opts)+ if err != nil {+ t.Fatalf("Pack: %v", err)+ }+ got, err := Unpack(env, tc.opts.Passphrase)+ if err != nil {+ t.Fatalf("Unpack: %v", err)+ }+ if !bytes.Equal(got, secret) {+ t.Errorf("round-trip mismatch: got %q", got)+ }+ })+ }+}++func TestWrongPassphraseFails(t *testing.T) {+ env, err := Pack(secret, Options{Passphrase: []byte("right")})+ if err != nil {+ t.Fatal(err)+ }+ if _, err := Unpack(env, []byte("wrong")); !errors.Is(err, ErrDecrypt) {+ t.Errorf("got %v want ErrDecrypt", err)+ }+}++func TestMissingPassphraseFails(t *testing.T) {+ env, err := Pack(secret, Options{Passphrase: []byte("right")})+ if err != nil {+ t.Fatal(err)+ }+ if _, err := Unpack(env, nil); !errors.Is(err, ErrPassphraseRequired) {+ t.Errorf("got %v want ErrPassphraseRequired", err)+ }+}++func TestTamperDetected(t *testing.T) {+ env, err := Pack(secret, Options{Passphrase: []byte("right")})+ if err != nil {+ t.Fatal(err)+ }+ env[len(env)-6] ^= 0xFF // flip a byte inside the ciphertext body+ if _, err := Unpack(env, []byte("right")); err == nil {+ t.Error("expected an error on tampered envelope")+ }+}++func TestChecksumMismatch(t *testing.T) {+ env, err := Pack(secret, Options{})+ if err != nil {+ t.Fatal(err)+ }+ env[len(env)-5] ^= 0xFF // flip a body byte on the plaintext path+ if _, err := Unpack(env, nil); !errors.Is(err, ErrChecksumMismatch) {+ t.Errorf("got %v want ErrChecksumMismatch", err)+ }+}++func TestBadMagic(t *testing.T) {+ env, _ := Pack(secret, Options{})+ env[0] ^= 0xFF+ if _, err := Unpack(env, nil); !errors.Is(err, ErrBadMagic) {+ t.Errorf("got %v want ErrBadMagic", err)+ }+}++func TestVersionReject(t *testing.T) {+ env, _ := Pack(secret, Options{})+ env[len(magic)] = 0x7F+ if _, err := Unpack(env, nil); !errors.Is(err, ErrUnsupportedVersion) {+ t.Errorf("got %v want ErrUnsupportedVersion", err)+ }+}++func TestTruncated(t *testing.T) {+ env, _ := Pack(secret, Options{})+ if _, err := Unpack(env[:5], nil); !errors.Is(err, ErrTruncated) {+ t.Errorf("got %v want ErrTruncated", err)+ }+}++func TestEmptyPayload(t *testing.T) {+ if _, err := Pack(nil, Options{}); !errors.Is(err, ErrEmptyPayload) {+ t.Errorf("got %v want ErrEmptyPayload", err)+ }+}++func TestHostileParamsRejected(t *testing.T) {+ env, err := Pack(secret, Options{Passphrase: []byte("right")})+ if err != nil {+ t.Fatal(err)+ }+ // zero out the Argon2 time field (offset magic+ver+flags+cipherID)+ timeOff := len(magic) + 1 + 1 + 1+ for i := 0; i < 4; i++ {+ env[timeOff+i] = 0+ }+ if _, err := Unpack(env, []byte("right")); !errors.Is(err, ErrBadParams) {+ t.Errorf("got %v want ErrBadParams", err)+ }+}++func TestValidateAndIsEncrypted(t *testing.T) {+ plain, _ := Pack(secret, Options{})+ enc, _ := Pack(secret, Options{Passphrase: []byte("k")})++ if err := Validate(plain); err != nil {+ t.Errorf("Validate(plain): %v", err)+ }+ if err := Validate([]byte("garbage")); err == nil {+ t.Error("Validate(garbage) should fail")+ }+ if e, _ := IsEncrypted(plain); e {+ t.Error("plain reported encrypted")+ }+ if e, _ := IsEncrypted(enc); !e {+ t.Error("encrypted reported plain")+ }+}++func TestStrengthParams(t *testing.T) {+ if p := paramsForStrength(StrengthHigh); p.memory != argonHighMemory || p.time != argonHighTime {+ t.Errorf("high params wrong: %+v", p)+ }+ if p := paramsForStrength(StrengthDefault); p.memory != argonDefaultMemory {+ t.Errorf("default params wrong: %+v", p)+ }+}diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/payload/payload.go b/PROJECTS/beginner/steganography-multi-tool/internal/payload/payload.gonew file mode 100644index 00000000..4dc532e6--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/internal/payload/payload.go@@ -0,0 +1,69 @@+/*+©AngelaMos | 2026+payload.go++Envelope types, constants, and errors shared across the crypha payload codec+*/++package payload++import "errors"++type Cipher string++const (+ CipherChaCha20 Cipher = "chacha20"+ CipherAES256GCM Cipher = "aes256gcm"+)++type Strength string++const (+ StrengthDefault Strength = "default"+ StrengthHigh Strength = "high"+)++type Options struct {+ Passphrase []byte+ Compress bool+ Cipher Cipher+ Strength Strength+}++const (+ currentVersion byte = 0x01++ flagEncrypted byte = 1 << 0+ flagCompressed byte = 1 << 1++ cipherIDChaCha20 byte = 0x00+ cipherIDAES256GCM byte = 0x01++ saltLen = 16+ nonceLen = 12+ keyLen = 32+ lenField = 4+ crcField = 4+ paramsLen = 9++ argonDefaultTime uint32 = 3+ argonDefaultMemory uint32 = 64 * 1024+ argonHighTime uint32 = 1+ argonHighMemory uint32 = 2048 * 1024+ argonMaxMemory uint32 = argonHighMemory+ argonThreads uint8 = 4+)++var magic = [4]byte{0xC7, 0x1A, 0x9E, 0x5B}++var (+ ErrEmptyPayload = errors.New("crypha: empty payload")+ ErrBadMagic = errors.New("crypha: not a crypha payload (bad magic)")+ ErrUnsupportedVersion = errors.New("crypha: unsupported envelope version")+ ErrTruncated = errors.New("crypha: truncated envelope")+ ErrBadParams = errors.New("crypha: invalid key-derivation parameters")+ ErrChecksumMismatch = errors.New("crypha: checksum mismatch")+ ErrPassphraseRequired = errors.New("crypha: payload is encrypted, passphrase required")+ ErrDecrypt = errors.New("crypha: decryption failed (wrong passphrase or tampered data)")+ ErrUnknownCipher = errors.New("crypha: unknown cipher")+)diff --git a/PROJECTS/beginner/steganography-multi-tool/justfile b/PROJECTS/beginner/steganography-multi-tool/justfilenew file mode 100644index 00000000..8cc8a2c1--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/justfile@@ -0,0 +1,89 @@+# =============================================================================+# ©AngelaMos | 2026+# justfile - crypha steganography multi-tool+# =============================================================================++set shell := ["bash", "-uc"]+set windows-shell := ["powershell.exe", "-NoLogo", "-Command"]++binary := "crypha"+version := `git describe --tags --always 2>/dev/null || echo "dev"`++# =============================================================================+# Default+# =============================================================================++default:+ @just --list --unsorted++# =============================================================================+# Formatting and Linting+# =============================================================================++[group('lint')]+fmt:+ gofmt -w -s cmd/ internal/++[group('lint')]+vet:+ go vet ./...++[group('lint')]+lint:+ GOTOOLCHAIN=go1.25.7 golangci-lint run ./...++# =============================================================================+# Testing+# =============================================================================++[group('test')]+test *ARGS:+ go test ./... {{ARGS}}++[group('test')]+test-race:+ go test -race ./...++[group('test')]+cov:+ go test -coverprofile=coverage.out ./...+ go tool cover -func=coverage.out++[group('test')]+cov-html: cov+ go tool cover -html=coverage.out++# =============================================================================+# Build and Run+# =============================================================================++[group('build')]+build:+ go build -o dist/{{binary}} ./cmd/{{binary}}++[group('build')]+run *ARGS:+ go run ./cmd/{{binary}} {{ARGS}}++# =============================================================================+# CI / Housekeeping+# =============================================================================++[group('ci')]+ci: fmt vet test build++[group('ci')]+tidy:+ go mod tidy++[group('ci')]+info:+ @echo "Binary: {{binary}}"+ @echo "Version: {{version}}"+ @echo "Go: $(go version)"++[group('ci')]+clean:+ -rm -rf dist+ -rm -f coverage.out+ @echo "Cleaned"