123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134 |
- // 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.
- // Package adler32 implements the Adler-32 checksum.
- //
- // It is defined in RFC 1950:
- // Adler-32 is composed of two sums accumulated per byte: s1 is
- // the sum of all bytes, s2 is the sum of all s1 values. Both sums
- // are done modulo 65521. s1 is initialized to 1, s2 to zero. The
- // Adler-32 checksum is stored as s2*65536 + s1 in most-
- // significant-byte first (network) order.
- package adler32
- import (
- "errors"
- "hash"
- )
- const (
- // mod is the largest prime that is less than 65536.
- mod = 65521
- // nmax is the largest n such that
- // 255 * n * (n+1) / 2 + (n+1) * (mod-1) <= 2^32-1.
- // It is mentioned in RFC 1950 (search for "5552").
- nmax = 5552
- )
- // The size of an Adler-32 checksum in bytes.
- const Size = 4
- // digest represents the partial evaluation of a checksum.
- // The low 16 bits are s1, the high 16 bits are s2.
- type digest uint32
- func (d *digest) Reset() { *d = 1 }
- // New returns a new hash.Hash32 computing the Adler-32 checksum. Its
- // Sum method will lay the value out in big-endian byte order. The
- // returned Hash32 also implements encoding.BinaryMarshaler and
- // encoding.BinaryUnmarshaler to marshal and unmarshal the internal
- // state of the hash.
- func New() hash.Hash32 {
- d := new(digest)
- d.Reset()
- return d
- }
- func (d *digest) Size() int { return Size }
- func (d *digest) BlockSize() int { return 4 }
- const (
- magic = "adl\x01"
- marshaledSize = len(magic) + 4
- )
- func (d *digest) MarshalBinary() ([]byte, error) {
- b := make([]byte, 0, marshaledSize)
- b = append(b, magic...)
- b = appendUint32(b, uint32(*d))
- return b, nil
- }
- func (d *digest) UnmarshalBinary(b []byte) error {
- if len(b) < len(magic) || string(b[:len(magic)]) != magic {
- return errors.New("hash/adler32: invalid hash state identifier")
- }
- if len(b) != marshaledSize {
- return errors.New("hash/adler32: invalid hash state size")
- }
- *d = digest(readUint32(b[len(magic):]))
- return nil
- }
- func appendUint32(b []byte, x uint32) []byte {
- a := [4]byte{
- byte(x >> 24),
- byte(x >> 16),
- byte(x >> 8),
- byte(x),
- }
- return append(b, a[:]...)
- }
- func readUint32(b []byte) uint32 {
- _ = b[3]
- return uint32(b[3]) | uint32(b[2])<<8 | uint32(b[1])<<16 | uint32(b[0])<<24
- }
- // Add p to the running checksum d.
- func update(d digest, p []byte) digest {
- s1, s2 := uint32(d&0xffff), uint32(d>>16)
- for len(p) > 0 {
- var q []byte
- if len(p) > nmax {
- p, q = p[:nmax], p[nmax:]
- }
- for len(p) >= 4 {
- s1 += uint32(p[0])
- s2 += s1
- s1 += uint32(p[1])
- s2 += s1
- s1 += uint32(p[2])
- s2 += s1
- s1 += uint32(p[3])
- s2 += s1
- p = p[4:]
- }
- for _, x := range p {
- s1 += uint32(x)
- s2 += s1
- }
- s1 %= mod
- s2 %= mod
- p = q
- }
- return digest(s2<<16 | s1)
- }
- func (d *digest) Write(p []byte) (nn int, err error) {
- *d = update(*d, p)
- return len(p), nil
- }
- func (d *digest) Sum32() uint32 { return uint32(*d) }
- func (d *digest) Sum(in []byte) []byte {
- s := uint32(*d)
- return append(in, byte(s>>24), byte(s>>16), byte(s>>8), byte(s))
- }
- // Checksum returns the Adler-32 checksum of data.
- func Checksum(data []byte) uint32 { return uint32(update(1, data)) }
|