コード例 #1
0
 public void write(byte[] b, int off, int len) throws IOException {
   digest.update(b, off, len);
   out.write(b, off, len);
 }
コード例 #2
0
  public int generateBytes(byte[] out, int outOff, int len)
      throws DataLengthException, IllegalArgumentException {
    if ((out.length - len) < outOff) {
      throw new DataLengthException("output buffer too small");
    }

    long oBytes = len;
    int outLen = digest.getDigestSize();

    //
    // this is at odds with the standard implementation, the
    // maximum value should be hBits * (2^32 - 1) where hBits
    // is the digest output size in bits. We can't have an
    // array with a long index at the moment...
    //
    if (oBytes > ((2L << 32) - 1)) {
      throw new IllegalArgumentException("Output length too large");
    }

    int cThreshold = (int) ((oBytes + outLen - 1) / outLen);

    byte[] dig = new byte[digest.getDigestSize()];

    int counter = 1;

    for (int i = 0; i < cThreshold; i++) {
      digest.update(z, 0, z.length);

      // OtherInfo
      ASN1EncodableVector v1 = new ASN1EncodableVector();
      // KeySpecificInfo
      ASN1EncodableVector v2 = new ASN1EncodableVector();

      v2.add(algorithm);
      v2.add(new DEROctetString(integerToBytes(counter)));

      v1.add(new DERSequence(v2));

      if (partyAInfo != null) {
        v1.add(new DERTaggedObject(true, 0, new DEROctetString(partyAInfo)));
      }

      v1.add(new DERTaggedObject(true, 2, new DEROctetString(integerToBytes(keySize))));

      byte[] other = new DERSequence(v1).getDEREncoded();

      digest.update(other, 0, other.length);

      digest.doFinal(dig, 0);

      if (len > outLen) {
        System.arraycopy(dig, 0, out, outOff, outLen);
        outOff += outLen;
        len -= outLen;
      } else {
        System.arraycopy(dig, 0, out, outOff, len);
      }

      counter++;
    }

    digest.reset();

    return len;
  }
コード例 #3
0
 public void write(int b) throws IOException {
   digest.update((byte) b);
   out.write(b);
 }