///

## Password hashing { #password-hashing }

"Hashing" means converting some content (a password in this case) into a sequence of bytes (just a string) that looks like gibberish.

Whenever you pass exactly the same content (exactly the same password) you get exactly the same gibberish.

But you cannot convert from the gibberish back to the password.

(apart from the KMS-generated ones) is 256 bits long. The KMS-generated keys may be 256 bits but this depends on the KMS capabilities and configuration.

The *Secure Channel* splits the object content into chunks of a fixed size of `65536` bytes. The last chunk may be smaller to avoid adding additional overhead and is treated specially to prevent truncation attacks. The nonce value is 96 bits long and generated randomly per object / multi-part part. The *Secure Channel* supports plaintexts...

        public int dec_ndr_long_and_advance(int count) {
            offset += 4 * count;
            return 0;
        }

        @Override
        public void advance(int bytes) {
            offset += bytes;
        }

        @Override
        public int getIndex() {
            return offset;
        }

        @Override
        public NdrBuffer derive(int offset) {

	if len(form) == 0 {
		return nil
	}

	sessionPolicyStr := form.Get(stsPolicy)
	if len(sessionPolicyStr) == 0 {
		return nil
	}

	sessionPolicy, err := policy.ParseConfig(bytes.NewReader([]byte(sessionPolicyStr)))
	if err != nil {
		return err
	}

	// Version in policy must not be empty
	if sessionPolicy.Version == "" {
		return errors.New("Version cannot be empty expecting '2012-10-17'")

func (z dataUsageHashMap) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendArrayHeader(o, uint32(len(z)))
	for zb0004 := range z {
		o = msgp.AppendString(o, zb0004)
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *dataUsageHashMap) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0002 uint32

 *       allocating garbage).
 * </ul>
 *
 * <p>Disadvantages compared to {@code long[]}:
 *
 * <ul>
 *   <li>Memory footprint has a fixed overhead (about 24 bytes per instance).
 *   <li><i>Some</i> construction use cases force the data to be copied (though several construction
 *       APIs are offered that don't).

 *       allocating garbage).
 * </ul>
 *
 * <p>Disadvantages compared to {@code int[]}:
 *
 * <ul>
 *   <li>Memory footprint has a fixed overhead (about 24 bytes per instance).
 *   <li><i>Some</i> construction use cases force the data to be copied (though several construction
 *       APIs are offered that don't).

		}()

		block := newMetacacheWriter(buf, 1<<20)
		defer block.Close()
		finishBlock := func() {
			if err := block.Close(); err != nil {
				w.streamErr = err
				return
			}
			current.data = buf.Bytes()
			w.streamErr = nextBlock(&current)
			// Prepare for next
			current.n++
			buf.Reset()
			block.Reset(buf)
			current.First = ""
		}
		for o := range in {

    }

    /**
     * Returns the length of this {@code SmbFile} in bytes. If this object
     * is a {@code TYPE_SHARE} the total capacity of the disk shared in
     * bytes is returned. If this object is a directory or a type other than
     * {@code TYPE_SHARE}, 0L is returned.
     *
     * @return The length of the file in bytes or 0 if this
     * <code>SmbFile</code> is not a file.

pkg bytes, method (*Buffer) Bytes() []uint8
pkg bytes, method (*Buffer) Len() int
pkg bytes, method (*Buffer) Next(int) []uint8
pkg bytes, method (*Buffer) Read([]uint8) (int, error)
pkg bytes, method (*Buffer) ReadByte() (uint8, error)
pkg bytes, method (*Buffer) ReadBytes(uint8) ([]uint8, error)
pkg bytes, method (*Buffer) ReadFrom(io.Reader) (int64, error)
pkg bytes, method (*Buffer) ReadRune() (int32, int, error)