obscure - obscure.go

     1  // Package obscure is used wrap a reader with an obscuring layer, using a cipher that is generated using a user-specified key.
     2  package obscure
     3  
     4  import (
     5  	"bufio"
     6  	"crypto/md5"
     7  	"encoding/binary"
     8  	"io"
     9  	"math/rand"
    10  	"slices"
    11  	"unicode"
    12  	"unicode/utf8"
    13  )
    14  
    15  // Encoder wraps an io.Reader and will replace letters and numbers using a
    16  // simple cipher.
    17  type Encoder struct {
    18  	m    map[rune]rune
    19  	r    *bufio.Reader
    20  	skip int
    21  }
    22  
    23  // NewEncoder generates a new cipher using the given key, and wraps the Reader
    24  // so it can be encoded.
    25  //
    26  // The decode flag, when set to true, will reverse the encoding.
    27  func NewEncoder(key []byte, f io.Reader, decode bool) *Encoder {
    28  	m := newCipherMap(key, decode)
    29  
    30  	return &Encoder{m: m, r: bufio.NewReader(f)}
    31  }
    32  
    33  func newCipherMap(key []byte, flip bool) map[rune]rune {
    34  	h := md5.Sum(key)
    35  	r := rand.New(rand.NewSource(int64(binary.LittleEndian.Uint64(h[:8]))))
    36  
    37  	return cipher(r, flip, unicode.Lower, unicode.Upper, unicode.Number)
    38  }
    39  
    40  func cipher(r *rand.Rand, flip bool, sets ...*unicode.RangeTable) map[rune]rune {
    41  	m := make(map[rune]rune)
    42  
    43  	for _, set := range sets {
    44  		cipherRanges16(m, r, flip, set.R16)
    45  		cipherRanges32(m, r, flip, set.R32)
    46  	}
    47  
    48  	return m
    49  }
    50  
    51  func cipherRanges16(m map[rune]rune, r *rand.Rand, flip bool, ranges []unicode.Range16) {
    52  	var chars [4][]rune
    53  
    54  	for _, rng := range ranges {
    55  		for c := rng.Lo; c < rng.Hi; c += rng.Stride {
    56  			l := utf8.RuneLen(rune(c))
    57  
    58  			chars[l-1] = append(chars[l-1], rune(c))
    59  		}
    60  	}
    61  
    62  	shuffleToMap(m, r, flip, chars)
    63  }
    64  
    65  func cipherRanges32(m map[rune]rune, r *rand.Rand, flip bool, ranges []unicode.Range32) {
    66  	var chars [4][]rune
    67  
    68  	for _, rng := range ranges {
    69  		for c := rng.Lo; c < rng.Hi; c += rng.Stride {
    70  			l := utf8.RuneLen(rune(c))
    71  
    72  			chars[l-1] = append(chars[l-1], rune(c))
    73  		}
    74  	}
    75  
    76  	shuffleToMap(m, r, flip, chars)
    77  }
    78  
    79  func shuffleToMap(m map[rune]rune, r *rand.Rand, flip bool, splitChars [4][]rune) {
    80  	for _, chars := range splitChars {
    81  		for a, c := range shuffle(r, slices.Clone(chars)) {
    82  			if flip {
    83  				m[c] = chars[a]
    84  			} else {
    85  				m[chars[a]] = c
    86  			}
    87  		}
    88  	}
    89  }
    90  
    91  func shuffle[T any](r *rand.Rand, s []T) []T {
    92  	for i := len(s) - 1; i > 0; i-- {
    93  		j := r.Intn(i + 1)
    94  		s[i], s[j] = s[j], s[i]
    95  	}
    96  
    97  	return s
    98  }
    99  
   100  func (e *Encoder) Read(p []byte) (int, error) {
   101  	var buf [4]byte
   102  
   103  	q := p
   104  
   105  	for len(q) > 0 {
   106  		r, s, err := e.r.ReadRune()
   107  		if err != nil {
   108  			return len(p) - len(q), err
   109  		}
   110  
   111  		if c, ok := e.m[r]; ok {
   112  			r = c
   113  		}
   114  
   115  		n := copy(q, buf[e.skip:utf8.EncodeRune(buf[:], r)])
   116  		q = q[n:]
   117  		e.skip = (e.skip + n) % s
   118  	}
   119  
   120  	if e.skip > 0 {
   121  		e.r.UnreadRune()
   122  	}
   123  
   124  	return len(p), nil
   125  }
   126