1 files changed, 0 insertions, 124 deletions
diff --git a/src/pkg/crypto/block/xor.go b/src/pkg/crypto/block/xor.go
deleted file mode 100644
index 9d8b17224..000000000
--- a/src/pkg/crypto/block/xor.go
+++ /dev/null
@@ -1,124 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Encrypt/decrypt data by xor with a pseudo-random data stream.
-
-package block
-
-import (
-	"io"
-	"os"
-)
-
-// A dataStream is an interface to an unending stream of data,
-// used by XorReader and XorWriter to model a pseudo-random generator.
-// Calls to Next() return sequential blocks of data from the stream.
-// Each call must return at least one byte: there is no EOF.
-type dataStream interface {
-	Next() []byte
-}
-
-type xorReader struct {
-	r    io.Reader
-	rand dataStream // pseudo-random
-	buf  []byte     // data available from last call to rand
-}
-
-func newXorReader(rand dataStream, r io.Reader) io.Reader {
-	x := new(xorReader)
-	x.r = r
-	x.rand = rand
-	return x
-}
-
-func (x *xorReader) Read(p []byte) (n int, err os.Error) {
-	n, err = x.r.Read(p)
-
-	// xor input with stream.
-	bp := 0
-	buf := x.buf
-	for i := 0; i < n; i++ {
-		if bp >= len(buf) {
-			buf = x.rand.Next()
-			bp = 0
-		}
-		p[i] ^= buf[bp]
-		bp++
-	}
-	x.buf = buf[bp:]
-	return n, err
-}
-
-type xorWriter struct {
-	w     io.Writer
-	rand  dataStream // pseudo-random
-	buf   []byte     // last buffer returned by rand
-	extra []byte     // extra random data (use before buf)
-	work  []byte     // work space
-}
-
-func newXorWriter(rand dataStream, w io.Writer) io.Writer {
-	x := new(xorWriter)
-	x.w = w
-	x.rand = rand
-	x.work = make([]byte, 4096)
-	return x
-}
-
-func (x *xorWriter) Write(p []byte) (n int, err os.Error) {
-	for len(p) > 0 {
-		// Determine next chunk of random data
-		// and xor with p into x.work.
-		var chunk []byte
-		m := len(p)
-		if nn := len(x.extra); nn > 0 {
-			// extra points into work, so edit directly
-			if m > nn {
-				m = nn
-			}
-			for i := 0; i < m; i++ {
-				x.extra[i] ^= p[i]
-			}
-			chunk = x.extra[0:m]
-		} else {
-			// xor p ^ buf into work, refreshing buf as needed
-			if nn := len(x.work); m > nn {
-				m = nn
-			}
-			bp := 0
-			buf := x.buf
-			for i := 0; i < m; i++ {
-				if bp >= len(buf) {
-					buf = x.rand.Next()
-					bp = 0
-				}
-				x.work[i] = buf[bp] ^ p[i]
-				bp++
-			}
-			x.buf = buf[bp:]
-			chunk = x.work[0:m]
-		}
-
-		// Write chunk.
-		var nn int
-		nn, err = x.w.Write(chunk)
-		if nn != len(chunk) && err == nil {
-			err = io.ErrShortWrite
-		}
-		if nn < len(chunk) {
-			// Reconstruct the random bits from the unwritten
-			// data and save them for next time.
-			for i := nn; i < m; i++ {
-				chunk[i] ^= p[i]
-			}
-			x.extra = chunk[nn:]
-		}
-		n += nn
-		if err != nil {
-			return
-		}
-		p = p[m:]
-	}
-	return
-}