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): add qr carrier with reed-solomon error injection (M6)
CarterPerez-dev0ae323eb5dd3
diff --git a/PROJECTS/beginner/steganography-multi-tool/go.mod b/PROJECTS/beginner/steganography-multi-tool/go.modindex c427d71a..d9201611 100644--- a/PROJECTS/beginner/steganography-multi-tool/go.mod+++ b/PROJECTS/beginner/steganography-multi-tool/go.mod@@ -5,8 +5,10 @@ go 1.25.0require (github.com/go-audio/audio v1.0.0github.com/go-audio/wav v1.1.0+ github.com/makiuchi-d/gozxing v0.1.1github.com/mewkiz/flac v1.0.13github.com/pdfcpu/pdfcpu v0.13.0+ github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686egithub.com/spf13/cobra v1.10.2golang.org/x/crypto v0.52.0golang.org/x/image v0.44.0@@ -27,5 +29,6 @@ require (github.com/pkg/errors v0.9.1 // indirectgithub.com/spf13/pflag v1.0.10 // indirectgolang.org/x/sys v0.47.0 // indirect+ golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirectgopkg.in/yaml.v2 v2.4.0 // indirect)diff --git a/PROJECTS/beginner/steganography-multi-tool/go.sum b/PROJECTS/beginner/steganography-multi-tool/go.sumindex d9dc8938..cef14c9a 100644--- a/PROJECTS/beginner/steganography-multi-tool/go.sum+++ b/PROJECTS/beginner/steganography-multi-tool/go.sum@@ -19,6 +19,8 @@ github.com/icza/mighty v0.0.0-20180919140131-cfd07d671de6 h1:8UsGZ2rr2ksmEru6lTogithub.com/icza/mighty v0.0.0-20180919140131-cfd07d671de6/go.mod h1:xQig96I1VNBDIWGCdTt54nHt6EeI639SmHycLYL7FkA=github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=+github.com/makiuchi-d/gozxing v0.1.1 h1:xxqijhoedi+/lZlhINteGbywIrewVdVv2wl9r5O9S1I=+github.com/makiuchi-d/gozxing v0.1.1/go.mod h1:eRIHbOjX7QWxLIDJoQuMLhuXg9LAuw6znsUtRkNw9DU=github.com/mattn/go-runewidth v0.0.24 h1:cpokDiIn0MGnhdHwuWnJBITySJ20QyNGnY2kR/ay2DU=github.com/mattn/go-runewidth v0.0.24/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=github.com/mewkiz/flac v1.0.13 h1:6wF8rRQKBFW159Daqx6Ro7K5ZnlVhHUKfS5aTsC4oXs=@@ -32,6 +34,8 @@ github.com/pdfcpu/pdfcpu v0.13.0/go.mod h1:Pz8elxcY3MHc3W65HeeDbuSBvsq+OK+enMVdBgithub.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=+github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e h1:MRM5ITcdelLK2j1vwZ3Je0FKVCfqOLp5zO6trqMLYs0=+github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e/go.mod h1:XV66xRDqSt+GTGFMVlhk3ULuV0y9ZmzeVGR4mloJI3M=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/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=@@ -46,6 +50,8 @@ golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=golang.org/x/text v0.40.0 h1:Ub2Z6/xjgF1WrYQz2nuITOEegKFtiIy+rieRJ5lHZKs=golang.org/x/text v0.40.0/go.mod h1:hpnzDAfGV753zIKo+wk3u1bVKCGPbrnF7+7LBF/UHVY=+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/carrier/all/all.go b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/all/all.goindex 127b7783..1181c081 100644--- a/PROJECTS/beginner/steganography-multi-tool/internal/carrier/all/all.go+++ b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/all/all.go@@ -11,5 +11,6 @@ import (_ "github.com/CarterPerez-dev/crypha/internal/carrier/audio"_ "github.com/CarterPerez-dev/crypha/internal/carrier/image"_ "github.com/CarterPerez-dev/crypha/internal/carrier/pdf"+ _ "github.com/CarterPerez-dev/crypha/internal/carrier/qr"_ "github.com/CarterPerez-dev/crypha/internal/carrier/text")diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/blocks.go b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/blocks.gonew file mode 100644index 00000000..cfa28783--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/blocks.go@@ -0,0 +1,190 @@+/*+©AngelaMos | 2026+blocks.go++Version and error-correction block tables (level H) plus codeword interleaving from ISO/IEC 18004+*/++package qr++const (+ ecLevelHigh = 2+ framePrefixBytes = 4+ bitsPerCodeword = 8+ injectionSafetyRatio = 2+ minSupportedVersion = 1+ maxSupportedVersion = 10+ baseSymbolSize = 21+ versionSizeStep = 4+)++type blockGroup struct {+ count int+ total int+ data int+}++type qrVersion struct {+ version int+ remainderBits int+ groups []blockGroup+}++var versionTable = map[int]qrVersion{+ 1: {1, 0, []blockGroup{{1, 26, 9}}},+ 2: {2, 7, []blockGroup{{1, 44, 16}}},+ 3: {3, 7, []blockGroup{{2, 35, 13}}},+ 4: {4, 7, []blockGroup{{4, 25, 9}}},+ 5: {5, 7, []blockGroup{{2, 33, 11}, {2, 34, 12}}},+ 6: {6, 7, []blockGroup{{4, 43, 15}}},+ 7: {7, 0, []blockGroup{{4, 39, 13}, {1, 40, 14}}},+ 8: {8, 0, []blockGroup{{4, 40, 14}, {2, 41, 15}}},+ 9: {9, 0, []blockGroup{{4, 36, 12}, {4, 37, 13}}},+ 10: {10, 0, []blockGroup{{6, 43, 15}, {2, 44, 16}}},+}++func lookupVersion(version int) (qrVersion, bool) {+ v, ok := versionTable[version]+ return v, ok+}++func symbolSize(version int) int {+ return baseSymbolSize + (version-1)*versionSizeStep+}++func versionForSize(size int) (int, bool) {+ if size < baseSymbolSize || (size-baseSymbolSize)%versionSizeStep != 0 {+ return 0, false+ }+ version := (size-baseSymbolSize)/versionSizeStep + 1+ if version < minSupportedVersion || version > maxSupportedVersion {+ return 0, false+ }+ return version, true+}++func (v qrVersion) numBlocks() int {+ n := 0+ for _, g := range v.groups {+ n += g.count+ }+ return n+}++func (v qrVersion) totalCodewords() int {+ n := 0+ for _, g := range v.groups {+ n += g.count * g.total+ }+ return n+}++func (v qrVersion) ecPerBlock() int {+ return v.groups[0].total - v.groups[0].data+}++func (v qrVersion) correctable() int {+ return v.ecPerBlock() / 2+}++func (v qrVersion) injectPerBlock() int {+ return v.correctable() / injectionSafetyRatio+}++func (v qrVersion) dataModules() int {+ return v.totalCodewords()*bitsPerCodeword + v.remainderBits+}++func (v qrVersion) capacityBytes() int {+ usable := v.numBlocks()*v.injectPerBlock() - framePrefixBytes+ if usable < 0 {+ return 0+ }+ return usable+}++func (v qrVersion) blockLayout() (dataLens, ecLens []int) {+ for _, g := range v.groups {+ for i := 0; i < g.count; i++ {+ dataLens = append(dataLens, g.data)+ ecLens = append(ecLens, g.total-g.data)+ }+ }+ return dataLens, ecLens+}++func (v qrVersion) interleave(dataBlocks, ecBlocks [][]byte) []byte {+ out := make([]byte, 0, v.totalCodewords())+ maxData := 0+ for _, b := range dataBlocks {+ if len(b) > maxData {+ maxData = len(b)+ }+ }+ for i := 0; i < maxData; i++ {+ for _, b := range dataBlocks {+ if i < len(b) {+ out = append(out, b[i])+ }+ }+ }+ maxEC := 0+ for _, b := range ecBlocks {+ if len(b) > maxEC {+ maxEC = len(b)+ }+ }+ for i := 0; i < maxEC; i++ {+ for _, b := range ecBlocks {+ if i < len(b) {+ out = append(out, b[i])+ }+ }+ }+ return out+}++func (v qrVersion) deinterleave(serial []byte) (dataBlocks, ecBlocks [][]byte, ok bool) {+ if len(serial) < v.totalCodewords() {+ return nil, nil, false+ }+ dataLens, ecLens := v.blockLayout()+ nb := len(dataLens)+ dataBlocks = make([][]byte, nb)+ ecBlocks = make([][]byte, nb)+ for b := 0; b < nb; b++ {+ dataBlocks[b] = make([]byte, dataLens[b])+ ecBlocks[b] = make([]byte, ecLens[b])+ }++ pos := 0+ maxData := 0+ for _, d := range dataLens {+ if d > maxData {+ maxData = d+ }+ }+ for i := 0; i < maxData; i++ {+ for b := 0; b < nb; b++ {+ if i < dataLens[b] {+ dataBlocks[b][i] = serial[pos]+ pos+++ }+ }+ }+ maxEC := 0+ for _, e := range ecLens {+ if e > maxEC {+ maxEC = e+ }+ }+ for i := 0; i < maxEC; i++ {+ for b := 0; b < nb; b++ {+ if i < ecLens[b] {+ ecBlocks[b][i] = serial[pos]+ pos+++ }+ }+ }+ return dataBlocks, ecBlocks, true+}diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/gf.go b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/gf.gonew file mode 100644index 00000000..f8d4f5c1--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/gf.go@@ -0,0 +1,57 @@+/*+©AngelaMos | 2026+gf.go++Arithmetic over GF(2^8) under the QR primitive polynomial for Reed-Solomon coding+*/++package qr++const (+ gfOrder = 255+ gfFieldSize = 256+ gfPrimitive = 0x11D+ gfGenerator = 2+ gfHighBit = 0x100+)++var (+ gfExp [gfOrder * 2]byte+ gfLog [gfFieldSize]byte+)++func init() {+ x := 1+ for i := 0; i < gfOrder; i++ {+ gfExp[i] = byte(x)+ gfLog[x] = byte(i)+ x <<= 1+ if x&gfHighBit != 0 {+ x ^= gfPrimitive+ }+ }+ for i := gfOrder; i < gfOrder*2; i++ {+ gfExp[i] = gfExp[i-gfOrder]+ }+}++func gfMul(a, b byte) byte {+ if a == 0 || b == 0 {+ return 0+ }+ return gfExp[int(gfLog[a])+int(gfLog[b])]+}++func gfInv(a byte) byte {+ return gfExp[gfOrder-int(gfLog[a])]+}++func gfPow(base byte, exp int) byte {+ if base == 0 {+ if exp == 0 {+ return 1+ }+ return 0+ }+ return gfExp[(int(gfLog[base])*exp)%gfOrder]+}diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/matrix.go b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/matrix.gonew file mode 100644index 00000000..702afd52--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/matrix.go@@ -0,0 +1,343 @@+/*+©AngelaMos | 2026+matrix.go++QR module geometry from ISO/IEC 18004: function map, format info, masks, placement, rendering+*/++package qr++import (+ "fmt"+ "image"+ "image/color"+ "image/png"+ "io"+ "math/bits"+)++const (+ quietZoneModules = 4+ modulePixels = 8+ darkThreshold = 128+ formatBitCount = 15+ formatDataBits = 5+ formatGenPoly = 0x537+ formatMaskPoly = 0x5412+ formatMaxDistance = 3+ formatCodeCount = 32+ alignmentRadius = 2+ timingLine = 6+ finderBlockEdge = 8+ finderPatternSize = 7+ versionInfoOrigin = 11+ versionInfoModules = 18+ versionInfoBand = 3+ minVersionWithInfo = 7+ darkLight = 0xFF+ darkDark = 0x00+)++var formatBitCells = [formatBitCount]point{+ {8, 0}, {8, 1}, {8, 2}, {8, 3}, {8, 4}, {8, 5},+ {8, 7}, {8, 8}, {7, 8},+ {5, 8}, {4, 8}, {3, 8}, {2, 8}, {1, 8}, {0, 8},+}++var alignmentCenters = map[int][]int{+ 1: {},+ 2: {6, 18},+ 3: {6, 22},+ 4: {6, 26},+ 5: {6, 30},+ 6: {6, 34},+ 7: {6, 22, 38},+ 8: {6, 24, 42},+ 9: {6, 26, 46},+ 10: {6, 28, 50},+}++type matrix struct {+ size int+ grid [][]bool+}++type point struct {+ x, y int+}++func newMatrix(size int) matrix {+ grid := make([][]bool, size)+ for i := range grid {+ grid[i] = make([]bool, size)+ }+ return matrix{size: size, grid: grid}+}++func (m matrix) clone() matrix {+ out := newMatrix(m.size)+ for y := range m.grid {+ copy(out.grid[y], m.grid[y])+ }+ return out+}++func functionModules(version int) [][]bool {+ size := symbolSize(version)+ isFunc := make([][]bool, size)+ for i := range isFunc {+ isFunc[i] = make([]bool, size)+ }+ mark := func(x, y int) {+ if x >= 0 && x < size && y >= 0 && y < size {+ isFunc[y][x] = true+ }+ }++ for y := 0; y <= finderBlockEdge; y++ {+ for x := 0; x <= finderBlockEdge; x++ {+ mark(x, y)+ }+ }+ for y := 0; y <= finderBlockEdge; y++ {+ for x := size - finderBlockEdge; x < size; x++ {+ mark(x, y)+ }+ }+ for y := size - finderBlockEdge; y < size; y++ {+ for x := 0; x <= finderBlockEdge; x++ {+ mark(x, y)+ }+ }++ for i := 0; i < size; i++ {+ mark(timingLine, i)+ mark(i, timingLine)+ }++ centers := alignmentCenters[version]+ for _, cx := range centers {+ for _, cy := range centers {+ if inFinderBlock(cx, cy, size) {+ continue+ }+ for dy := -alignmentRadius; dy <= alignmentRadius; dy++ {+ for dx := -alignmentRadius; dx <= alignmentRadius; dx++ {+ mark(cx+dx, cy+dy)+ }+ }+ }+ }++ if version >= minVersionWithInfo {+ for i := 0; i < versionInfoModules; i++ {+ mark(i/versionInfoBand, size-versionInfoOrigin+i%versionInfoBand)+ mark(size-versionInfoOrigin+i%versionInfoBand, i/versionInfoBand)+ }+ }++ return isFunc+}++func inFinderBlock(cx, cy, size int) bool {+ span := finderPatternSize + 1+ inTopLeft := cx < span && cy < span+ inTopRight := cx >= size-span && cy < span+ inBottomLeft := cx < span && cy >= size-span+ return inTopLeft || inTopRight || inBottomLeft+}++func maskBit(maskID, row, col int) bool {+ switch maskID {+ case 0:+ return (row+col)%2 == 0+ case 1:+ return row%2 == 0+ case 2:+ return col%3 == 0+ case 3:+ return (row+col)%3 == 0+ case 4:+ return (row/2+col/3)%2 == 0+ case 5:+ return (row*col)%2+(row*col)%3 == 0+ case 6:+ return ((row*col)%2+(row*col)%3)%2 == 0+ case 7:+ return ((row+col)%2+(row*col)%3)%2 == 0+ }+ return false+}++func formatCode(dataBits int) int {+ remainder := dataBits << (formatBitCount - formatDataBits)+ for i := formatBitCount - 1; i >= formatBitCount-formatDataBits; i-- {+ if remainder&(1<<i) != 0 {+ remainder ^= formatGenPoly << (i - (formatBitCount - formatDataBits))+ }+ }+ return ((dataBits << (formatBitCount - formatDataBits)) | remainder) ^ formatMaskPoly+}++func readFormatBits(m matrix) int {+ value := 0+ for i, cell := range formatBitCells {+ if m.grid[cell.y][cell.x] {+ value |= 1 << i+ }+ }+ return value+}++func parseFormat(m matrix) (maskID, level int, ok bool) {+ stored := readFormatBits(m)+ bestDist := formatBitCount + 1+ bestData := -1+ for d := 0; d < formatCodeCount; d++ {+ dist := bits.OnesCount(uint(stored ^ formatCode(d)))+ if dist < bestDist {+ bestDist = dist+ bestData = d+ }+ }+ if bestData < 0 || bestDist > formatMaxDistance {+ return 0, 0, false+ }+ return bestData & 0x7, bestData >> 3, true+}++func placementOrder(version int, isFunc [][]bool) []point {+ size := symbolSize(version)+ v, _ := lookupVersion(version)+ count := v.dataModules()+ order := make([]point, 0, count)++ xOffset := 1+ dirUp := true+ x := size - 2+ y := size - 1++ for i := 0; i < count; i++ {+ order = append(order, point{x: x + xOffset, y: y})+ if i == count-1 {+ break+ }+ for {+ if xOffset == 1 {+ xOffset = 0+ } else {+ xOffset = 1+ if dirUp {+ if y > 0 {+ y--+ } else {+ dirUp = false+ x -= 2+ }+ } else {+ if y < size-1 {+ y+++ } else {+ dirUp = true+ x -= 2+ }+ }+ }+ if x == timingLine-1 {+ x--+ }+ if x < 0 {+ return order+ }+ if !isFunc[y][x+xOffset] {+ break+ }+ }+ }+ return order+}++func readSerial(m matrix, order []point, maskID, totalCodewords int) []byte {+ out := make([]byte, totalCodewords)+ for c := 0; c < totalCodewords; c++ {+ var b byte+ for bit := 0; bit < bitsPerCodeword; bit++ {+ p := order[c*bitsPerCodeword+bit]+ v := m.grid[p.y][p.x]+ if maskBit(maskID, p.y, p.x) {+ v = !v+ }+ b <<= 1+ if v {+ b |= 1+ }+ }+ out[c] = b+ }+ return out+}++func writeSerial(m matrix, order []point, maskID int, serial []byte) {+ for c := 0; c < len(serial); c++ {+ b := serial[c]+ for bit := 0; bit < bitsPerCodeword; bit++ {+ p := order[c*bitsPerCodeword+bit]+ v := (b>>(7-bit))&1 == 1+ if maskBit(maskID, p.y, p.x) {+ v = !v+ }+ m.grid[p.y][p.x] = v+ }+ }+}++func renderPNG(m matrix, out io.Writer) error {+ dim := (m.size + 2*quietZoneModules) * modulePixels+ img := image.NewGray(image.Rect(0, 0, dim, dim))+ for i := range img.Pix {+ img.Pix[i] = darkLight+ }+ for y := 0; y < m.size; y++ {+ for x := 0; x < m.size; x++ {+ if !m.grid[y][x] {+ continue+ }+ px := (x + quietZoneModules) * modulePixels+ py := (y + quietZoneModules) * modulePixels+ for dy := 0; dy < modulePixels; dy++ {+ for dx := 0; dx < modulePixels; dx++ {+ img.SetGray(px+dx, py+dy, color.Gray{Y: darkDark})+ }+ }+ }+ }+ return png.Encode(out, img)+}++func readGrid(r io.Reader) (matrix, int, error) {+ img, _, err := image.Decode(r)+ if err != nil {+ return matrix{}, 0, fmt.Errorf("crypha/qr: decode stego: %w", err)+ }+ b := img.Bounds()+ width, height := b.Dx(), b.Dy()+ if width != height || width%modulePixels != 0 {+ return matrix{}, 0, ErrNotQR+ }+ across := width / modulePixels+ size := across - 2*quietZoneModules+ version, ok := versionForSize(size)+ if !ok {+ return matrix{}, 0, ErrNotQR+ }+ m := newMatrix(size)+ for y := 0; y < size; y++ {+ for x := 0; x < size; x++ {+ cx := b.Min.X + (quietZoneModules+x)*modulePixels + modulePixels/2+ cy := b.Min.Y + (quietZoneModules+y)*modulePixels + modulePixels/2+ gray := color.GrayModel.Convert(img.At(cx, cy)).(color.Gray)+ m.grid[y][x] = gray.Y < darkThreshold+ }+ }+ return m, version, nil+}diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/matrix_test.go b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/matrix_test.gonew file mode 100644index 00000000..47f2545d--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/matrix_test.go@@ -0,0 +1,121 @@+/*+©AngelaMos | 2026+matrix_test.go++Unit coverage for QR geometry: mask formulas, version sizing, and capacity edge cases+*/++package qr++import (+ "bytes"+ "strings"+ "testing"+)++func TestMaskFormulas(t *testing.T) {+ cases := []struct {+ maskID int+ row, col int+ want bool+ }{+ {0, 0, 0, true}, {0, 0, 1, false},+ {1, 0, 3, true}, {1, 1, 3, false},+ {2, 4, 0, true}, {2, 4, 1, false},+ {3, 0, 0, true}, {3, 0, 1, false},+ {4, 0, 0, true}, {4, 2, 0, false},+ {5, 0, 0, true}, {5, 1, 1, false},+ {6, 1, 1, true}, {6, 1, 5, false},+ {7, 0, 0, true}, {7, 0, 1, false},+ }+ for _, tc := range cases {+ if got := maskBit(tc.maskID, tc.row, tc.col); got != tc.want {+ t.Fatalf("maskBit(%d,%d,%d): got %v want %v", tc.maskID, tc.row, tc.col, got, tc.want)+ }+ }+ if maskBit(99, 0, 0) {+ t.Fatal("maskBit with out-of-range id should be false")+ }+}++func TestFunctionMapCountMatchesDataModules(t *testing.T) {+ for version := minSupportedVersion; version <= maxSupportedVersion; version++ {+ isFunc := functionModules(version)+ size := symbolSize(version)+ funcCount := 0+ for y := 0; y < size; y++ {+ for x := 0; x < size; x++ {+ if isFunc[y][x] {+ funcCount+++ }+ }+ }+ if nonFunc := size*size - funcCount; nonFunc != versionTable[version].dataModules() {+ t.Fatalf("v%d: non-function modules %d, want dataModules %d", version, nonFunc, versionTable[version].dataModules())+ }+ }+}++func TestVersionForSize(t *testing.T) {+ cases := []struct {+ size int+ version int+ ok bool+ }{+ {21, 1, true},+ {25, 2, true},+ {57, 10, true},+ {17, 0, false},+ {23, 0, false},+ {61, 0, false},+ }+ for _, tc := range cases {+ version, ok := versionForSize(tc.size)+ if ok != tc.ok || version != tc.version {+ t.Fatalf("versionForSize(%d): got (%d,%v) want (%d,%v)", tc.size, version, ok, tc.version, tc.ok)+ }+ }+}++func TestCapacityBytesFloorsAtZero(t *testing.T) {+ tiny := qrVersion{version: 0, groups: []blockGroup{{count: 1, total: 9, data: 8}}}+ if got := tiny.capacityBytes(); got != 0 {+ t.Fatalf("capacityBytes for a sub-frame budget: got %d want 0", got)+ }+}++func TestSupportedVersionCapacities(t *testing.T) {+ want := map[int]int{+ 1: 0, 2: 3, 3: 6, 4: 12, 5: 16,+ 6: 24, 7: 26, 8: 32, 9: 44, 10: 52,+ }+ for version := minSupportedVersion; version <= maxSupportedVersion; version++ {+ if got := versionTable[version].capacityBytes(); got != want[version] {+ t.Fatalf("v%d capacity: got %d want %d", version, got, want[version])+ }+ }+}++func TestRoundTripAcrossCovers(t *testing.T) {+ covers := []string{+ "crypha",+ "https://angelamos.com/x",+ "TEST 123",+ "The quick brown fox jumps",+ "0123456789",+ }+ secret := []byte("covert channel")+ for _, cover := range covers {+ var stego bytes.Buffer+ if err := (qrCarrier{}).Hide(strings.NewReader(cover), secret, &stego); err != nil {+ t.Fatalf("Hide cover %q: %v", cover, err)+ }+ got, err := (qrCarrier{}).Reveal(bytes.NewReader(stego.Bytes()))+ if err != nil {+ t.Fatalf("Reveal cover %q: %v", cover, err)+ }+ if !bytes.Equal(got, secret) {+ t.Fatalf("cover %q: round-trip mismatch", cover)+ }+ }+}diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/qr.go b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/qr.gonew file mode 100644index 00000000..a65bd1e7--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/qr.go@@ -0,0 +1,266 @@+/*+©AngelaMos | 2026+qr.go++QR carrier that hides a payload as Reed-Solomon-correctable errors so scanners self-heal to the cover+*/++package qr++import (+ "encoding/binary"+ "errors"+ "fmt"+ "io"++ "github.com/CarterPerez-dev/crypha/internal/carrier"+ qrcode "github.com/skip2/go-qrcode"+)++const Format = "qr"++var (+ ErrEmptyPayload = errors.New("crypha/qr: empty payload")+ ErrCoverRequired = errors.New("crypha/qr: qr cover text is required")+ ErrCoverTooLarge = errors.New("crypha/qr: cover text too large for the supported qr versions")+ ErrPayloadTooLarge = errors.New("crypha/qr: payload exceeds carrier capacity")+ ErrNoPayload = errors.New("crypha/qr: no crypha payload found")+ ErrNotQR = errors.New("crypha/qr: stego is not a crypha qr image")+ errBadSymbol = errors.New("crypha/qr: unexpected qr symbol geometry")+)++type qrCarrier struct{}++func init() {+ carrier.Register(qrCarrier{})+}++func (qrCarrier) Format() string {+ return Format+}++func (qrCarrier) Hide(cover io.Reader, payload []byte, out io.Writer) error {+ if len(payload) == 0 {+ return ErrEmptyPayload+ }+ coverText, err := io.ReadAll(cover)+ if err != nil {+ return fmt.Errorf("crypha/qr: read cover: %w", err)+ }+ if len(coverText) == 0 {+ return ErrCoverRequired+ }+ if len(payload) > maxCapacity() {+ return fmt.Errorf("%w: need %d bytes, max is %d", ErrPayloadTooLarge, len(payload), maxCapacity())+ }++ code, version, err := selectVersion(string(coverText), len(payload))+ if err != nil {+ return err+ }++ clean, err := matrixFromBitmap(code.Bitmap(), version)+ if err != nil {+ return err+ }++ maskID, level, ok := parseFormat(clean)+ if !ok || level != ecLevelHigh {+ return errBadSymbol+ }++ spec, _ := lookupVersion(version)+ isFunc := functionModules(version)+ order := placementOrder(version, isFunc)+ serial := readSerial(clean, order, maskID, spec.totalCodewords())++ dataBlocks, ecBlocks, ok := spec.deinterleave(serial)+ if !ok {+ return errBadSymbol+ }++ framed := frame(payload)+ if err := injectFramed(dataBlocks, spec, framed); err != nil {+ return err+ }++ stego := clean.clone()+ writeSerial(stego, order, maskID, spec.interleave(dataBlocks, ecBlocks))+ return renderPNG(stego, out)+}++func (qrCarrier) Reveal(stego io.Reader) ([]byte, error) {+ m, version, err := readGrid(stego)+ if err != nil {+ return nil, err+ }++ maskID, level, ok := parseFormat(m)+ if !ok || level != ecLevelHigh {+ return nil, ErrNoPayload+ }++ spec, _ := lookupVersion(version)+ isFunc := functionModules(version)+ order := placementOrder(version, isFunc)+ serial := readSerial(m, order, maskID, spec.totalCodewords())++ dataBlocks, ecBlocks, ok := spec.deinterleave(serial)+ if !ok {+ return nil, ErrNoPayload+ }++ framed, err := extractFramed(dataBlocks, ecBlocks, spec)+ if err != nil {+ return nil, err+ }+ return unframe(framed)+}++func (qrCarrier) Capacity(cover io.Reader) (int, error) {+ coverText, err := io.ReadAll(cover)+ if err != nil {+ return 0, fmt.Errorf("crypha/qr: read cover: %w", err)+ }+ if len(coverText) == 0 {+ return 0, ErrCoverRequired+ }+ best := 0+ for version := minSupportedVersion; version <= maxSupportedVersion; version++ {+ if _, err := qrcode.NewWithForcedVersion(string(coverText), version, qrcode.Highest); err != nil {+ continue+ }+ if c := versionTable[version].capacityBytes(); c > best {+ best = c+ }+ }+ return best, nil+}++func (qrCarrier) Sniff(stego io.ReadSeeker) bool {+ m, _, err := readGrid(stego)+ if err != nil {+ return false+ }+ return hasFinderPatterns(m)+}++func selectVersion(coverText string, payloadLen int) (*qrcode.QRCode, int, error) {+ coverFits := false+ for version := minSupportedVersion; version <= maxSupportedVersion; version++ {+ spec := versionTable[version]+ code, err := qrcode.NewWithForcedVersion(coverText, version, qrcode.Highest)+ if err != nil {+ continue+ }+ coverFits = true+ if spec.capacityBytes() < payloadLen {+ continue+ }+ code.DisableBorder = true+ return code, version, nil+ }+ if !coverFits {+ return nil, 0, ErrCoverTooLarge+ }+ return nil, 0, fmt.Errorf("%w: need %d bytes", ErrPayloadTooLarge, payloadLen)+}++func matrixFromBitmap(bitmap [][]bool, version int) (matrix, error) {+ size := symbolSize(version)+ if len(bitmap) != size {+ return matrix{}, errBadSymbol+ }+ m := newMatrix(size)+ for y := 0; y < size; y++ {+ if len(bitmap[y]) != size {+ return matrix{}, errBadSymbol+ }+ copy(m.grid[y], bitmap[y])+ }+ return m, nil+}++func injectFramed(dataBlocks [][]byte, spec qrVersion, framed []byte) error {+ nb := spec.numBlocks()+ inject := spec.injectPerBlock()+ for t := 0; t < len(framed); t++ {+ block := t % nb+ slot := t / nb+ if slot >= inject || slot >= len(dataBlocks[block]) {+ return fmt.Errorf("%w: framed length %d", ErrPayloadTooLarge, len(framed))+ }+ dataBlocks[block][slot] ^= framed[t]+ }+ return nil+}++func extractFramed(dataBlocks, ecBlocks [][]byte, spec qrVersion) ([]byte, error) {+ nb := spec.numBlocks()+ inject := spec.injectPerBlock()+ ec := spec.ecPerBlock()++ clean := make([][]byte, nb)+ for b := 0; b < nb; b++ {+ recv := append(append([]byte(nil), dataBlocks[b]...), ecBlocks[b]...)+ corrected, err := rsDecode(recv, ec)+ if err != nil {+ return nil, ErrNoPayload+ }+ clean[b] = corrected[:len(dataBlocks[b])]+ }++ framed := make([]byte, nb*inject)+ for t := 0; t < len(framed); t++ {+ block := t % nb+ slot := t / nb+ framed[t] = clean[block][slot] ^ dataBlocks[block][slot]+ }+ return framed, nil+}++func frame(payload []byte) []byte {+ out := make([]byte, framePrefixBytes+len(payload))+ binary.BigEndian.PutUint32(out, uint32(len(payload)))+ copy(out[framePrefixBytes:], payload)+ return out+}++func unframe(framed []byte) ([]byte, error) {+ if len(framed) < framePrefixBytes {+ return nil, ErrNoPayload+ }+ length := binary.BigEndian.Uint32(framed)+ if length == 0 || uint64(length) > uint64(len(framed)-framePrefixBytes) {+ return nil, ErrNoPayload+ }+ out := make([]byte, length)+ copy(out, framed[framePrefixBytes:framePrefixBytes+int(length)])+ return out, nil+}++func hasFinderPatterns(m matrix) bool {+ return isFinder(m, 0, 0) &&+ isFinder(m, m.size-finderPatternSize, 0) &&+ isFinder(m, 0, m.size-finderPatternSize)+}++func isFinder(m matrix, ox, oy int) bool {+ if ox < 0 || oy < 0 || ox+finderPatternSize > m.size || oy+finderPatternSize > m.size {+ return false+ }+ for y := 0; y < finderPatternSize; y++ {+ for x := 0; x < finderPatternSize; x++ {+ border := x == 0 || x == finderPatternSize-1 || y == 0 || y == finderPatternSize-1+ center := x >= 2 && x <= 4 && y >= 2 && y <= 4+ if m.grid[oy+y][ox+x] != (border || center) {+ return false+ }+ }+ }+ return true+}++func maxCapacity() int {+ return versionTable[maxSupportedVersion].capacityBytes()+}diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/qr_test.go b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/qr_test.gonew file mode 100644index 00000000..f8f9a8f2--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/qr_test.go@@ -0,0 +1,444 @@+/*+©AngelaMos | 2026+qr_test.go++Differential tests against skip2 and gozxing plus round-trip, capacity, sniff, and registry checks+*/++package qr++import (+ "bytes"+ "errors"+ stdimage "image"+ "image/png"+ "strings"+ "testing"++ "github.com/CarterPerez-dev/crypha/internal/carrier"+ "github.com/CarterPerez-dev/crypha/internal/payload"+ gozxing "github.com/makiuchi-d/gozxing"+ gozxingqr "github.com/makiuchi-d/gozxing/qrcode"+ qrcode "github.com/skip2/go-qrcode"+)++type errReader struct{}++func (errReader) Read([]byte) (int, error) {+ return 0, errors.New("crypha/qr test: forced read error")+}++const testCover = "crypha"++func qrRandom(n, seed int) []byte {+ b := make([]byte, n)+ x := uint32(seed)*2654435761 + 1+ for i := range b {+ x = x*1664525 + 1013904223+ b[i] = byte(x >> 24)+ }+ return b+}++func skip2Clean(t *testing.T, cover string, version int) matrix {+ t.Helper()+ code, err := qrcode.NewWithForcedVersion(cover, version, qrcode.Highest)+ if err != nil {+ t.Fatalf("skip2 encode v%d: %v", version, err)+ }+ code.DisableBorder = true+ m, err := matrixFromBitmap(code.Bitmap(), version)+ if err != nil {+ t.Fatalf("matrixFromBitmap v%d: %v", version, err)+ }+ return m+}++func hideReveal(t *testing.T, cover string, payloadBytes []byte) []byte {+ t.Helper()+ var stego bytes.Buffer+ if err := (qrCarrier{}).Hide(strings.NewReader(cover), payloadBytes, &stego); err != nil {+ t.Fatalf("Hide: %v", err)+ }+ got, err := (qrCarrier{}).Reveal(bytes.NewReader(stego.Bytes()))+ if err != nil {+ t.Fatalf("Reveal: %v", err)+ }+ return got+}++func decodeWithGozxing(t *testing.T, pngBytes []byte) string {+ t.Helper()+ img, _, err := stdimage.Decode(bytes.NewReader(pngBytes))+ if err != nil {+ t.Fatalf("decode stego png: %v", err)+ }+ bmp, err := gozxing.NewBinaryBitmapFromImage(img)+ if err != nil {+ t.Fatalf("gozxing bitmap: %v", err)+ }+ res, err := gozxingqr.NewQRCodeReader().Decode(bmp, nil)+ if err != nil {+ t.Fatalf("gozxing decode: %v", err)+ }+ return res.GetText()+}++func TestFormatCodeKAT(t *testing.T) {+ cases := map[int]int{+ 0: 0x5412,+ 1: 0x5125,+ 9: 0x72f3,+ 16: 0x1689,+ 31: 0x2bed,+ }+ for data, want := range cases {+ if got := formatCode(data); got != want {+ t.Fatalf("formatCode(%d): got %#x want %#x", data, got, want)+ }+ }+}++func TestCleanBlocksAreValidRSCodewords(t *testing.T) {+ for version := minSupportedVersion; version <= maxSupportedVersion; version++ {+ clean := skip2Clean(t, testCover, version)+ maskID, level, ok := parseFormat(clean)+ if !ok {+ t.Fatalf("v%d: parseFormat failed", version)+ }+ if level != ecLevelHigh {+ t.Fatalf("v%d: parsed level %d want %d", version, level, ecLevelHigh)+ }+ spec := versionTable[version]+ order := placementOrder(version, functionModules(version))+ if len(order) != spec.dataModules() {+ t.Fatalf("v%d: placement visited %d modules want %d", version, len(order), spec.dataModules())+ }+ serial := readSerial(clean, order, maskID, spec.totalCodewords())+ dataBlocks, ecBlocks, ok := spec.deinterleave(serial)+ if !ok {+ t.Fatalf("v%d: deinterleave failed", version)+ }+ for b := range dataBlocks {+ recv := append(append([]byte(nil), dataBlocks[b]...), ecBlocks[b]...)+ if !rsAllZero(rsSyndromes(recv, spec.ecPerBlock())) {+ t.Fatalf("v%d block %d: extracted codeword is not a valid RS codeword", version, b)+ }+ }+ }+}++func TestReadWriteSymmetry(t *testing.T) {+ for version := minSupportedVersion; version <= maxSupportedVersion; version++ {+ clean := skip2Clean(t, testCover, version)+ maskID, _, _ := parseFormat(clean)+ spec := versionTable[version]+ order := placementOrder(version, functionModules(version))+ serial := readSerial(clean, order, maskID, spec.totalCodewords())+ dataBlocks, ecBlocks, _ := spec.deinterleave(serial)++ rebuilt := clean.clone()+ writeSerial(rebuilt, order, maskID, spec.interleave(dataBlocks, ecBlocks))+ for y := 0; y < clean.size; y++ {+ for x := 0; x < clean.size; x++ {+ if rebuilt.grid[y][x] != clean.grid[y][x] {+ t.Fatalf("v%d: re-render differs at (%d,%d)", version, x, y)+ }+ }+ }+ }+}++func TestRoundTrip(t *testing.T) {+ cases := []struct {+ name string+ payload []byte+ }{+ {"single byte", []byte{0x42}},+ {"embedded zeros", []byte{0x00, 0x00, 0xFF, 0x00, 0x7F}},+ {"tiny text", []byte("hi")},+ {"medium text", []byte("meet at the docks")},+ {"twenty four bytes", bytes.Repeat([]byte{0xAB}, 24)},+ {"twenty six bytes", bytes.Repeat([]byte{0x5A}, 26)},+ {"high bits", bytes.Repeat([]byte{0xFF}, 40)},+ }+ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ got := hideReveal(t, testCover, tc.payload)+ if !bytes.Equal(got, tc.payload) {+ t.Fatalf("round-trip mismatch: got %x want %x", got, tc.payload)+ }+ })+ }+}++func TestRandomBinaryRoundTrip(t *testing.T) {+ for _, size := range []int{1, 3, 12, 27, 44, 52} {+ payloadBytes := qrRandom(size, size*7+1)+ got := hideReveal(t, testCover, payloadBytes)+ if !bytes.Equal(got, payloadBytes) {+ t.Fatalf("random round-trip mismatch at size %d", size)+ }+ }+}++func TestStegoDecodesToCoverViaGozxing(t *testing.T) {+ covers := []string{"crypha", "https://angelamos.com", "HELLO WORLD 123"}+ for _, cover := range covers {+ var stego bytes.Buffer+ if err := (qrCarrier{}).Hide(strings.NewReader(cover), qrRandom(16, len(cover)), &stego); err != nil {+ t.Fatalf("Hide cover %q: %v", cover, err)+ }+ if got := decodeWithGozxing(t, stego.Bytes()); got != cover {+ t.Fatalf("gozxing decoded stego to %q, want cover %q", got, cover)+ }+ }+}++func TestPerVersionMaxCapacityRoundTripAndScan(t *testing.T) {+ for version := minSupportedVersion; version <= maxSupportedVersion; version++ {+ capBytes := versionTable[version].capacityBytes()+ if capBytes == 0 {+ continue+ }+ payloadBytes := qrRandom(capBytes, version*101+7)+ var stego bytes.Buffer+ if err := (qrCarrier{}).Hide(strings.NewReader(testCover), payloadBytes, &stego); err != nil {+ t.Fatalf("v%d Hide at capacity %d: %v", version, capBytes, err)+ }+ got, err := (qrCarrier{}).Reveal(bytes.NewReader(stego.Bytes()))+ if err != nil {+ t.Fatalf("v%d Reveal: %v", version, err)+ }+ if !bytes.Equal(got, payloadBytes) {+ t.Fatalf("v%d: round-trip mismatch at max capacity", version)+ }+ if scanned := decodeWithGozxing(t, stego.Bytes()); scanned != testCover {+ t.Fatalf("v%d: at full injection budget, gozxing decoded %q want cover %q", version, scanned, testCover)+ }+ }+}++func TestCleanQRHasNoPayload(t *testing.T) {+ clean := skip2Clean(t, testCover, 6)+ var buf bytes.Buffer+ if err := renderPNG(clean, &buf); err != nil {+ t.Fatalf("render clean: %v", err)+ }+ if _, err := (qrCarrier{}).Reveal(bytes.NewReader(buf.Bytes())); err != ErrNoPayload {+ t.Fatalf("clean QR reveal: got %v want ErrNoPayload", err)+ }+}++func TestCapacityBoundary(t *testing.T) {+ atCap := bytes.Repeat([]byte{0x01}, maxCapacity())+ if got := hideReveal(t, testCover, atCap); !bytes.Equal(got, atCap) {+ t.Fatal("payload at exact capacity failed to round-trip")+ }+ over := bytes.Repeat([]byte{0x01}, maxCapacity()+1)+ err := (qrCarrier{}).Hide(strings.NewReader(testCover), over, &bytes.Buffer{})+ if err == nil {+ t.Fatal("expected capacity error for oversized payload")+ }+}++func TestCapacityReport(t *testing.T) {+ got, err := (qrCarrier{}).Capacity(strings.NewReader(testCover))+ if err != nil {+ t.Fatalf("Capacity: %v", err)+ }+ if got != maxCapacity() {+ t.Fatalf("Capacity: got %d want %d", got, maxCapacity())+ }+}++func TestCapacityTooLargeCoverIsZero(t *testing.T) {+ large := strings.Repeat("a", 200)+ got, err := (qrCarrier{}).Capacity(strings.NewReader(large))+ if err != nil {+ t.Fatalf("Capacity: %v", err)+ }+ if got != 0 {+ t.Fatalf("Capacity for a cover too large for any version: got %d want 0", got)+ }+}++func TestEmptyPayloadRejected(t *testing.T) {+ if err := (qrCarrier{}).Hide(strings.NewReader(testCover), nil, &bytes.Buffer{}); err != ErrEmptyPayload {+ t.Fatalf("expected ErrEmptyPayload, got %v", err)+ }+}++func TestEmptyCoverRejected(t *testing.T) {+ if err := (qrCarrier{}).Hide(strings.NewReader(""), []byte("x"), &bytes.Buffer{}); err != ErrCoverRequired {+ t.Fatalf("expected ErrCoverRequired, got %v", err)+ }+}++func TestCoverTooLargeRejected(t *testing.T) {+ huge := strings.Repeat("A", 4000)+ err := (qrCarrier{}).Hide(strings.NewReader(huge), []byte("x"), &bytes.Buffer{})+ if err != ErrCoverTooLarge {+ t.Fatalf("expected ErrCoverTooLarge, got %v", err)+ }+}++func TestEncryptedEnvelopeExceedsQRCapacity(t *testing.T) {+ env, err := payload.Pack([]byte("secret"), payload.Options{+ Passphrase: []byte("correct horse battery staple"),+ Cipher: payload.CipherChaCha20,+ Strength: payload.StrengthDefault,+ })+ if err != nil {+ t.Fatalf("Pack: %v", err)+ }+ if len(env) <= maxCapacity() {+ t.Fatalf("encrypted envelope is %d bytes, expected to exceed qr capacity %d", len(env), maxCapacity())+ }+ err = (qrCarrier{}).Hide(strings.NewReader(testCover), env, &bytes.Buffer{})+ if err == nil {+ t.Fatal("expected oversized encrypted envelope to be rejected")+ }+}++func TestUnencryptedEnvelopeThroughCarrier(t *testing.T) {+ secret := []byte("qr covert")+ env, err := payload.Pack(secret, payload.Options{Compress: true})+ if err != nil {+ t.Fatalf("Pack: %v", err)+ }+ got := hideReveal(t, testCover, env)+ if !bytes.Equal(got, env) {+ t.Fatal("carrier did not return the exact envelope bytes")+ }+ plain, err := payload.Unpack(got, nil)+ if err != nil {+ t.Fatalf("Unpack: %v", err)+ }+ if !bytes.Equal(plain, secret) {+ t.Fatalf("end-to-end mismatch: got %q want %q", plain, secret)+ }+}++func TestSniff(t *testing.T) {+ var stego bytes.Buffer+ if err := (qrCarrier{}).Hide(strings.NewReader(testCover), []byte("payload"), &stego); err != nil {+ t.Fatalf("Hide: %v", err)+ }++ plain := stdimage.NewGray(stdimage.Rect(0, 0, 200, 200))+ for i := range plain.Pix {+ plain.Pix[i] = 0xFF+ }+ var notQR bytes.Buffer+ if err := png.Encode(¬QR, plain); err != nil {+ t.Fatalf("encode plain png: %v", err)+ }++ cases := []struct {+ name string+ data []byte+ want bool+ }{+ {"stego qr", stego.Bytes(), true},+ {"blank png", notQR.Bytes(), false},+ {"garbage", []byte("not an image at all"), false},+ }+ for _, tc := range cases {+ t.Run(tc.name, func(t *testing.T) {+ if got := (qrCarrier{}).Sniff(bytes.NewReader(tc.data)); got != tc.want {+ t.Fatalf("Sniff(%s): got %v want %v", tc.name, got, tc.want)+ }+ })+ }+}++func TestRevealRejectsGarbage(t *testing.T) {+ if _, err := (qrCarrier{}).Reveal(bytes.NewReader([]byte("garbage"))); err == nil {+ t.Fatal("expected decode error for garbage input")+ }+ plain := stdimage.NewGray(stdimage.Rect(0, 0, 200, 200))+ for i := range plain.Pix {+ plain.Pix[i] = 0xFF+ }+ var blank bytes.Buffer+ if err := png.Encode(&blank, plain); err != nil {+ t.Fatalf("encode blank: %v", err)+ }+ if _, err := (qrCarrier{}).Reveal(bytes.NewReader(blank.Bytes())); err == nil {+ t.Fatal("blank png reveal: expected an error, got nil")+ }+}++func TestRegisteredInRegistry(t *testing.T) {+ c, ok := carrier.Get(Format)+ if !ok {+ t.Fatal("qr carrier did not self-register")+ }+ if c.Format() != Format {+ t.Fatalf("registry returned wrong carrier: %s", c.Format())+ }+}++func TestReadErrorsPropagate(t *testing.T) {+ if err := (qrCarrier{}).Hide(errReader{}, []byte("x"), &bytes.Buffer{}); err == nil {+ t.Fatal("Hide: expected cover read error")+ }+ if _, err := (qrCarrier{}).Capacity(errReader{}); err == nil {+ t.Fatal("Capacity: expected cover read error")+ }+ if _, err := (qrCarrier{}).Reveal(errReader{}); err == nil {+ t.Fatal("Reveal: expected stego read error")+ }+}++func TestUnframeRejectsBadLength(t *testing.T) {+ if _, err := unframe([]byte{0, 1}); err != ErrNoPayload {+ t.Fatalf("short frame: got %v want ErrNoPayload", err)+ }+ if _, err := unframe([]byte{0, 0, 0, 0}); err != ErrNoPayload {+ t.Fatalf("zero-length frame: got %v want ErrNoPayload", err)+ }+ if _, err := unframe([]byte{0, 0, 0, 10, 1, 2, 3}); err != ErrNoPayload {+ t.Fatalf("overlong length prefix: got %v want ErrNoPayload", err)+ }+}++func TestMatrixFromBitmapRejectsWrongSize(t *testing.T) {+ tooSmall := make([][]bool, 10)+ if _, err := matrixFromBitmap(tooSmall, 1); err != errBadSymbol {+ t.Fatalf("wrong height: got %v want errBadSymbol", err)+ }+ raggedRows := make([][]bool, symbolSize(1))+ for i := range raggedRows {+ raggedRows[i] = make([]bool, 5)+ }+ if _, err := matrixFromBitmap(raggedRows, 1); err != errBadSymbol {+ t.Fatalf("wrong width: got %v want errBadSymbol", err)+ }+}++func TestInjectFramedRejectsOverflow(t *testing.T) {+ spec := versionTable[2]+ dataBlocks := [][]byte{make([]byte, spec.groups[0].data)}+ oversized := make([]byte, spec.numBlocks()*spec.injectPerBlock()+1)+ if err := injectFramed(dataBlocks, spec, oversized); !errors.Is(err, ErrPayloadTooLarge) {+ t.Fatalf("overflow inject: got %v want ErrPayloadTooLarge", err)+ }+}++func TestSniffRejectsNonFinderImage(t *testing.T) {+ size := symbolSize(1)+ dim := (size + 2*quietZoneModules) * modulePixels+ white := stdimage.NewGray(stdimage.Rect(0, 0, dim, dim))+ for i := range white.Pix {+ white.Pix[i] = 0xFF+ }+ var buf bytes.Buffer+ if err := png.Encode(&buf, white); err != nil {+ t.Fatalf("encode white qr-sized png: %v", err)+ }+ if (qrCarrier{}).Sniff(bytes.NewReader(buf.Bytes())) {+ t.Fatal("Sniff should reject a qr-sized image with no finder patterns")+ }+}diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/rs.go b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/rs.gonew file mode 100644index 00000000..35036219--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/rs.go@@ -0,0 +1,221 @@+/*+©AngelaMos | 2026+rs.go++Systematic Reed-Solomon over GF(2^8): encode plus a syndrome-Berlekamp-Massey decoder+*/++package qr++import "errors"++var (+ ErrRSInput = errors.New("crypha/qr: invalid reed-solomon block")+ ErrRSUncorrectable = errors.New("crypha/qr: reed-solomon block is uncorrectable")+)++func gfPolyEval(p []byte, x byte) byte {+ y := p[0]+ for i := 1; i < len(p); i++ {+ y = gfMul(y, x) ^ p[i]+ }+ return y+}++func gfPolyScale(p []byte, s byte) []byte {+ out := make([]byte, len(p))+ for i := range p {+ out[i] = gfMul(p[i], s)+ }+ return out+}++func gfPolyAdd(a, b []byte) []byte {+ n := len(a)+ if len(b) > n {+ n = len(b)+ }+ out := make([]byte, n)+ for i := range a {+ out[i+n-len(a)] = a[i]+ }+ for i := range b {+ out[i+n-len(b)] ^= b[i]+ }+ return out+}++func gfPolyMul(a, b []byte) []byte {+ out := make([]byte, len(a)+len(b)-1)+ for i := range a {+ for j := range b {+ out[i+j] ^= gfMul(a[i], b[j])+ }+ }+ return out+}++func rsGenerator(nsym int) []byte {+ g := []byte{1}+ for i := 0; i < nsym; i++ {+ g = gfPolyMul(g, []byte{1, gfPow(gfGenerator, i)})+ }+ return g+}++func rsEncode(data []byte, nsym int) []byte {+ gen := rsGenerator(nsym)+ out := make([]byte, len(data)+nsym)+ copy(out, data)+ for i := 0; i < len(data); i++ {+ coef := out[i]+ if coef != 0 {+ for j := 1; j < len(gen); j++ {+ out[i+j] ^= gfMul(gen[j], coef)+ }+ }+ }+ copy(out, data)+ return out+}++func rsSyndromes(recv []byte, nsym int) []byte {+ s := make([]byte, nsym)+ for i := 0; i < nsym; i++ {+ s[i] = gfPolyEval(recv, gfPow(gfGenerator, i))+ }+ return s+}++func rsAllZero(s []byte) bool {+ for _, v := range s {+ if v != 0 {+ return false+ }+ }+ return true+}++func rsErrorLocator(synd []byte) []byte {+ errLoc := []byte{1}+ oldLoc := []byte{1}+ for i := 0; i < len(synd); i++ {+ delta := synd[i]+ for j := 1; j < len(errLoc); j++ {+ delta ^= gfMul(errLoc[len(errLoc)-1-j], synd[i-j])+ }+ oldLoc = append(oldLoc, 0)+ if delta != 0 {+ if len(oldLoc) > len(errLoc) {+ newLoc := gfPolyScale(oldLoc, delta)+ oldLoc = gfPolyScale(errLoc, gfInv(delta))+ errLoc = newLoc+ }+ errLoc = gfPolyAdd(errLoc, gfPolyScale(oldLoc, delta))+ }+ }+ for len(errLoc) > 0 && errLoc[0] == 0 {+ errLoc = errLoc[1:]+ }+ return errLoc+}++func rsErrorPositions(errLoc []byte, n int) ([]int, bool) {+ numErr := len(errLoc) - 1+ positions := make([]int, 0, numErr)+ for p := 0; p < n; p++ {+ locator := gfPow(gfGenerator, (n-1-p)%gfOrder)+ if gfPolyEval(errLoc, gfInv(locator)) == 0 {+ positions = append(positions, p)+ }+ }+ if len(positions) != numErr {+ return nil, false+ }+ return positions, true+}++func rsSolveMagnitudes(locators, synd []byte) ([]byte, bool) {+ e := len(locators)+ matrix := make([][]byte, e)+ for row := 0; row < e; row++ {+ matrix[row] = make([]byte, e+1)+ for col := 0; col < e; col++ {+ matrix[row][col] = gfPow(locators[col], row)+ }+ matrix[row][e] = synd[row]+ }++ for col := 0; col < e; col++ {+ pivot := -1+ for row := col; row < e; row++ {+ if matrix[row][col] != 0 {+ pivot = row+ break+ }+ }+ if pivot < 0 {+ return nil, false+ }+ matrix[col], matrix[pivot] = matrix[pivot], matrix[col]+ inv := gfInv(matrix[col][col])+ for k := col; k <= e; k++ {+ matrix[col][k] = gfMul(matrix[col][k], inv)+ }+ for row := 0; row < e; row++ {+ if row != col && matrix[row][col] != 0 {+ factor := matrix[row][col]+ for k := col; k <= e; k++ {+ matrix[row][k] ^= gfMul(factor, matrix[col][k])+ }+ }+ }+ }++ magnitudes := make([]byte, e)+ for row := 0; row < e; row++ {+ magnitudes[row] = matrix[row][e]+ }+ for j := 0; j < len(synd); j++ {+ var acc byte+ for m := 0; m < e; m++ {+ acc ^= gfMul(magnitudes[m], gfPow(locators[m], j))+ }+ if acc != synd[j] {+ return nil, false+ }+ }+ return magnitudes, true+}++func rsDecode(recv []byte, nsym int) ([]byte, error) {+ if nsym <= 0 || len(recv) <= nsym || len(recv) > gfOrder {+ return nil, ErrRSInput+ }+ synd := rsSyndromes(recv, nsym)+ if rsAllZero(synd) {+ return append([]byte(nil), recv...), nil+ }+ errLoc := rsErrorLocator(synd)+ numErr := len(errLoc) - 1+ if numErr <= 0 || numErr > nsym/2 {+ return nil, ErrRSUncorrectable+ }+ positions, ok := rsErrorPositions(errLoc, len(recv))+ if !ok {+ return nil, ErrRSUncorrectable+ }+ locators := make([]byte, numErr)+ for m, p := range positions {+ locators[m] = gfPow(gfGenerator, (len(recv)-1-p)%gfOrder)+ }+ magnitudes, ok := rsSolveMagnitudes(locators, synd)+ if !ok {+ return nil, ErrRSUncorrectable+ }+ corrected := append([]byte(nil), recv...)+ for m, p := range positions {+ corrected[p] ^= magnitudes[m]+ }+ return corrected, nil+}diff --git a/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/rs_test.go b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/rs_test.gonew file mode 100644index 00000000..e8849e94--- /dev/null+++ b/PROJECTS/beginner/steganography-multi-tool/internal/carrier/qr/rs_test.go@@ -0,0 +1,199 @@+/*+©AngelaMos | 2026+rs_test.go++Field-table sanity plus Reed-Solomon encode/decode correctness under injected errors+*/++package qr++import (+ "bytes"+ "testing"+)++func rsRandom(n, seed int) []byte {+ b := make([]byte, n)+ x := uint32(seed)*2654435761 + 1+ for i := range b {+ x = x*1664525 + 1013904223+ b[i] = byte(x >> 24)+ }+ return b+}++func TestGFFieldTables(t *testing.T) {+ if gfExp[0] != 1 {+ t.Fatalf("gfExp[0]: got %d want 1", gfExp[0])+ }+ if gfExp[8] != 29 {+ t.Fatalf("gfExp[8]: got %d want 29 (primitive 0x11D)", gfExp[8])+ }+ if gfMul(2, 2) != 4 {+ t.Fatalf("gfMul(2,2): got %d want 4", gfMul(2, 2))+ }+ if gfPow(2, 8) != 29 {+ t.Fatalf("gfPow(2,8): got %d want 29", gfPow(2, 8))+ }+ for a := 1; a < gfFieldSize; a++ {+ if gfMul(byte(a), gfInv(byte(a))) != 1 {+ t.Fatalf("gfInv broken at %d", a)+ }+ }+ for a := 1; a < gfFieldSize; a++ {+ for b := 1; b < gfFieldSize; b++ {+ if gfMul(byte(a), byte(b)) != gfMul(byte(b), byte(a)) {+ t.Fatalf("gfMul not commutative at %d,%d", a, b)+ }+ }+ }+}++func TestGFPowEdges(t *testing.T) {+ if gfPow(gfGenerator, 0) != 1 {+ t.Fatalf("gfPow(2,0): got %d want 1", gfPow(gfGenerator, 0))+ }+ if gfPow(gfGenerator, gfOrder) != 1 {+ t.Fatalf("gfPow(2,255): got %d want 1", gfPow(gfGenerator, gfOrder))+ }+ if gfPow(0, 0) != 1 {+ t.Fatalf("gfPow(0,0): got %d want 1", gfPow(0, 0))+ }+ if gfPow(0, 5) != 0 {+ t.Fatalf("gfPow(0,5): got %d want 0", gfPow(0, 5))+ }+}++func TestRSGeneratorIsMonic(t *testing.T) {+ for _, nsym := range []int{7, 17, 22, 28} {+ gen := rsGenerator(nsym)+ if len(gen) != nsym+1 {+ t.Fatalf("generator degree: nsym=%d got len %d", nsym, len(gen))+ }+ if gen[0] != 1 {+ t.Fatalf("generator not monic: nsym=%d leading %d", nsym, gen[0])+ }+ }+}++func TestRSCleanRoundTrip(t *testing.T) {+ cases := []struct{ k, nsym int }{+ {9, 17},+ {13, 22},+ {16, 28},+ {15, 28},+ }+ for _, tc := range cases {+ data := rsRandom(tc.k, tc.k*tc.nsym)+ code := rsEncode(data, tc.nsym)+ if len(code) != tc.k+tc.nsym {+ t.Fatalf("encode length: got %d want %d", len(code), tc.k+tc.nsym)+ }+ if !bytes.Equal(code[:tc.k], data) {+ t.Fatal("encode is not systematic (data prefix altered)")+ }+ got, err := rsDecode(code, tc.nsym)+ if err != nil {+ t.Fatalf("decode clean codeword: %v", err)+ }+ if !bytes.Equal(got[:tc.k], data) {+ t.Fatal("clean decode did not return data")+ }+ }+}++func TestRSCorrectsUpToT(t *testing.T) {+ cases := []struct{ k, nsym int }{+ {9, 17},+ {13, 22},+ {16, 28},+ }+ for _, tc := range cases {+ n := tc.k + tc.nsym+ maxErr := tc.nsym / 2+ data := rsRandom(tc.k, tc.k+7*tc.nsym)+ clean := rsEncode(data, tc.nsym)+ for numErr := 1; numErr <= maxErr; numErr++ {+ corrupt := append([]byte(nil), clean...)+ offsets := rsRandom(numErr, numErr*97+tc.nsym)+ mags := rsRandom(numErr, numErr*131+tc.k)+ used := map[int]bool{}+ placed := 0+ for i := 0; placed < numErr; i++ {+ pos := int(offsets[placed%numErr]) % n+ pos = (pos + i) % n+ if used[pos] {+ continue+ }+ mag := mags[placed%numErr]+ if mag == 0 {+ mag = 1+ }+ corrupt[pos] ^= mag+ used[pos] = true+ placed+++ }+ got, err := rsDecode(corrupt, tc.nsym)+ if err != nil {+ t.Fatalf("k=%d nsym=%d numErr=%d: decode failed: %v", tc.k, tc.nsym, numErr, err)+ }+ if !bytes.Equal(got[:tc.k], data) {+ t.Fatalf("k=%d nsym=%d numErr=%d: did not recover data", tc.k, tc.nsym, numErr)+ }+ }+ }+}++func TestRSDoesNotFakeCorrectBeyondT(t *testing.T) {+ k, nsym := 13, 22+ n := k + nsym+ data := rsRandom(k, 999)+ clean := rsEncode(data, nsym)+ tooMany := nsym/2 + 1+ for seed := 0; seed < 16; seed++ {+ corrupt := append([]byte(nil), clean...)+ offsets := rsRandom(tooMany, seed*17+3)+ mags := rsRandom(tooMany, seed*29+5)+ used := map[int]bool{}+ placed := 0+ for i := 0; placed < tooMany; i++ {+ pos := (int(offsets[placed%tooMany]) + i) % n+ if used[pos] {+ continue+ }+ mag := mags[placed%tooMany]+ if mag == 0 {+ mag = 1+ }+ corrupt[pos] ^= mag+ used[pos] = true+ placed+++ }+ got, err := rsDecode(corrupt, nsym)+ if err == nil && bytes.Equal(got[:k], data) {+ t.Fatalf("seed %d: decoder silently recovered original from %d errors (> t)", seed, tooMany)+ }+ }+}++func TestGFPolyAddAsymmetric(t *testing.T) {+ want := []byte{1, 1, 0}+ if got := gfPolyAdd([]byte{1, 0, 1}, []byte{1, 1}); !bytes.Equal(got, want) {+ t.Fatalf("gfPolyAdd longer-first: got %v want %v", got, want)+ }+ if got := gfPolyAdd([]byte{1, 1}, []byte{1, 0, 1}); !bytes.Equal(got, want) {+ t.Fatalf("gfPolyAdd longer-second: got %v want %v", got, want)+ }+}++func TestRSRejectsMalformedBlocks(t *testing.T) {+ if _, err := rsDecode([]byte{1, 2, 3}, 0); err != ErrRSInput {+ t.Fatalf("nsym=0: got %v want ErrRSInput", err)+ }+ if _, err := rsDecode([]byte{1, 2, 3}, 3); err != ErrRSInput {+ t.Fatalf("recv==nsym: got %v want ErrRSInput", err)+ }+ if _, err := rsDecode([]byte{1, 2, 3}, 5); err != ErrRSInput {+ t.Fatalf("recv<nsym: got %v want ErrRSInput", err)+ }+}