init QMCv2: RC4 (512 Byte Key)

algo/qmc/rc4.go

@@ -0,0 +1,133 @@
+package qmc
+
+import (
+	"errors"
+)
+
+// A rc4Cipher is an instance of RC4 using a particular key.
+type rc4Cipher struct {
+	box    []byte
+	key    []byte
+	hash   uint32
+	boxTmp []byte
+}
+
+// NewRC4Cipher creates and returns a new rc4Cipher. The key argument should be the
+// RC4 key, at least 1 byte and at most 256 bytes.
+func NewRC4Cipher(key []byte) (*rc4Cipher, error) {
+	n := len(key)
+	if n == 0 {
+		return nil, errors.New("crypto/rc4: invalid key size")
+	}
+
+	var c = rc4Cipher{key: key}
+	c.box = make([]byte, n)
+	c.boxTmp = make([]byte, n)
+
+	for i := 0; i < n; i++ {
+		c.box[i] = byte(i)
+	}
+
+	var j = 0
+	for i := 0; i < n; i++ {
+		j = (j + int(c.box[i]) + int(key[i%n])) % n
+		c.box[i], c.box[j] = c.box[j], c.box[i]
+	}
+	c.getHashBase()
+	return &c, nil
+}
+
+func (c *rc4Cipher) getHashBase() {
+	c.hash = 1
+	for i := 0; i < len(c.key); i++ {
+		v := uint32(c.key[i])
+		if v == 0 {
+			continue
+		}
+		nextHash := c.hash * v
+		if nextHash == 0 || nextHash <= c.hash {
+			break
+		}
+		c.hash = nextHash
+	}
+}
+
+const rc4SegmentSize = 5120
+
+func (c *rc4Cipher) Process(src []byte, offset int) {
+	toProcess := len(src)
+	processed := 0
+	markProcess := func(p int) (finished bool) {
+		offset += p
+		toProcess -= p
+		processed += p
+		return toProcess == 0
+	}
+
+	if offset < 128 {
+		blockSize := toProcess
+		if blockSize > 128-offset {
+			blockSize = 128 - offset
+		}
+		c.encFirstSegment(src[:blockSize], offset)
+		if markProcess(blockSize) {
+			return
+		}
+	}
+
+	if offset%rc4SegmentSize != 0 {
+		blockSize := toProcess
+		if blockSize > rc4SegmentSize-offset%rc4SegmentSize {
+			blockSize = rc4SegmentSize - offset%rc4SegmentSize
+		}
+		k := src[processed : processed+blockSize]
+		c.encASegment(k, offset)
+		if markProcess(blockSize) {
+			return
+		}
+	}
+	for toProcess > rc4SegmentSize {
+		c.encASegment(src[processed:processed+rc4SegmentSize], offset)
+		markProcess(rc4SegmentSize)
+	}
+
+	if toProcess > 0 {
+		c.encASegment(src[processed:], offset)
+	}
+}
+func (c *rc4Cipher) encFirstSegment(buf []byte, offset int) {
+	n := len(c.box)
+	for i := 0; i < len(buf); i++ {
+		idx1 := offset + i
+		segmentID := int(c.key[idx1%n])
+		idx2 := int(float64(c.hash) / float64((idx1+1)*segmentID) * 100.0)
+		buf[i] ^= c.key[idx2%n]
+	}
+}
+
+func (c *rc4Cipher) encASegment(buf []byte, offset int) {
+	n := len(c.box)
+	copy(c.boxTmp, c.box)
+
+	segmentID := (offset / rc4SegmentSize) & 0x1FF
+
+	if n <= segmentID {
+		return
+	}
+
+	idx2 := int64(float64(c.hash) /
+		float64((offset/rc4SegmentSize+1)*int(c.key[segmentID])) *
+		100.0)
+	skipLen := int((idx2 & 0x1FF) + int64(offset%rc4SegmentSize))
+
+	j, k := 0, 0
+
+	for i := -skipLen; i < len(buf); i++ {
+		j = (j + 1) % n
+		k = (int(c.boxTmp[j]) + k) % n
+		c.boxTmp[j], c.boxTmp[k] = c.boxTmp[k], c.boxTmp[j]
+		if i >= 0 {
+			buf[i] ^= c.boxTmp[int(c.boxTmp[j])+int(c.boxTmp[k])%n]
+		}
+	}
+}