Java 类java.security.DigestException 实例源码

public static String SHA1(String decrypt) throws DigestException {
    //获取信息摘要 - 参数字典排序后字符串
    try {
        //指定sha1算法
        MessageDigest digest = MessageDigest
                .getInstance("SHA-1");
        digest.update(decrypt.getBytes());
        byte messageDigest[] = digest.digest();
        // Create Hex String
        StringBuilder hexString = new StringBuilder();
        // 字节数组转换为 十六进制 数
        for (byte aMessageDigest : messageDigest) {
            String shaHex = Integer.toHexString(aMessageDigest & 0xFF);
            if (shaHex.length() < 2) {
                hexString.append(0);
            }
            hexString.append(shaHex);
        }
        return hexString.toString();
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
        throw new DigestException("签名错误！");
    }
}

@Test
public void testPull() throws IOException, RegistryException, DigestException {
  // Pulls the busybox image.
  RegistryClient registryClient = new RegistryClient(null, "localhost:5000", "busybox");
  V21ManifestTemplate manifestTemplate =
      registryClient.pullManifest("latest", V21ManifestTemplate.class);

  DescriptorDigest realDigest = manifestTemplate.getLayerDigests().get(0);

  // Pulls a layer BLOB of the busybox image.
  Path destFile = temporaryFolder.newFile().toPath();
  Path checkBlobFile = temporaryFolder.newFile().toPath();

  Blob blob = registryClient.pullBlob(realDigest, destFile);

  try (OutputStream outputStream =
      new BufferedOutputStream(Files.newOutputStream(checkBlobFile))) {
    BlobDescriptor blobDescriptor = blob.writeTo(outputStream);
    Assert.assertEquals(realDigest, blobDescriptor.getDigest());
  }

  Assert.assertArrayEquals(Files.readAllBytes(destFile), Files.readAllBytes(checkBlobFile));
}

@Test
public void testPull_unknownBlob() throws RegistryException, IOException, DigestException {
  DescriptorDigest nonexistentDigest =
      DescriptorDigest.fromHash(
          "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");

  try {
    RegistryClient registryClient = new RegistryClient(null, "localhost:5000", "busybox");
    registryClient.pullBlob(nonexistentDigest, Mockito.mock(Path.class));
    Assert.fail("Trying to pull nonexistent blob should have errored");

  } catch (RegistryErrorException ex) {
    Assert.assertThat(
        ex.getMessage(),
        CoreMatchers.containsString(
            "pull BLOB for localhost:5000/busybox with digest " + nonexistentDigest));
  }
}

@Test
public void test_smokeTest() throws IOException, DigestException {
  for (Map.Entry<String, String> knownHash : knownSha256Hashes.entrySet()) {
    String toHash = knownHash.getKey();
    String expectedHash = knownHash.getValue();

    OutputStream underlyingOutputStream = new ByteArrayOutputStream();
    CountingDigestOutputStream countingDigestOutputStream =
        new CountingDigestOutputStream(underlyingOutputStream);

    byte[] bytesToHash = toHash.getBytes(StandardCharsets.UTF_8);
    InputStream toHashInputStream = new ByteArrayInputStream(bytesToHash);
    ByteStreams.copy(toHashInputStream, countingDigestOutputStream);

    BlobDescriptor expectedBlobDescriptor =
        new BlobDescriptor(bytesToHash.length, DescriptorDigest.fromHash(expectedHash));
    Assert.assertEquals(expectedBlobDescriptor, countingDigestOutputStream.toBlobDescriptor());
    Assert.assertEquals(bytesToHash.length, countingDigestOutputStream.getTotalBytes());
  }
}

@Before
public void setUp() throws DigestException {
  baseLayerBlobDescriptor =
      new BlobDescriptor(
          631,
          DescriptorDigest.fromDigest(
              "sha256:5f70bf18a086007016e948b04aed3b82103a36bea41755b6cddfaf10ace3c6ef"));
  baseLayerDiffId =
      DescriptorDigest.fromDigest(
          "sha256:b56ae66c29370df48e7377c8f9baa744a3958058a766793f821dadcb144a4647");
  classesLayerBlobDescriptor =
      new BlobDescriptor(
          223,
          DescriptorDigest.fromDigest(
              "sha256:8c662931926fa990b41da3c9f42663a537ccd498130030f9149173a0493832ad"));
  classesLayerDiffId =
      DescriptorDigest.fromDigest(
          "sha256:a3f3e99c29370df48e7377c8f9baa744a3958058a766793f821dadcb144a8372");
}

@Test
public void testGetLayerFile() throws DigestException {
  DescriptorDigest layerDigest =
      DescriptorDigest.fromDigest(
          "sha256:8c662931926fa990b41da3c9f42663a537ccd498130030f9149173a0493832ad");

  ArgumentCaptor<String> fileNameCaptor = ArgumentCaptor.forClass(String.class);

  Mockito.when(mockPath.resolve(fileNameCaptor.capture())).thenReturn(mockPath);

  Path layerFile = CacheFiles.getLayerFile(mockPath, layerDigest);

  Assert.assertEquals(
      "8c662931926fa990b41da3c9f42663a537ccd498130030f9149173a0493832ad.tar.gz",
      fileNameCaptor.getValue());
  Assert.assertEquals(mockPath, layerFile);
}

@Test
public void testToJson() throws IOException, URISyntaxException, DigestException {
  // Loads the expected JSON string.
  Path jsonFile = Paths.get(Resources.getResource("json/containerconfig.json").toURI());
  String expectedJson = new String(Files.readAllBytes(jsonFile), StandardCharsets.UTF_8);

  // Creates the JSON object to serialize.
  ContainerConfigurationTemplate containerConfigJson = new ContainerConfigurationTemplate();

  containerConfigJson.setContainerEnvironment(Arrays.asList("VAR1=VAL1", "VAR2=VAL2"));
  containerConfigJson.setContainerEntrypoint(Arrays.asList("some", "entrypoint", "command"));

  containerConfigJson.addLayerDiffId(
      DescriptorDigest.fromDigest(
          "sha256:8c662931926fa990b41da3c9f42663a537ccd498130030f9149173a0493832ad"));

  // Serializes the JSON object.
  ByteArrayOutputStream jsonStream = new ByteArrayOutputStream();
  JsonTemplateMapper.writeJson(jsonStream, containerConfigJson);

  Assert.assertEquals(expectedJson, jsonStream.toString());
}

@Test
public void testFromJson() throws IOException, URISyntaxException, DigestException {
  // Loads the JSON string.
  Path jsonFile = Paths.get(Resources.getResource("json/containerconfig.json").toURI());

  // Deserializes into a manifest JSON object.
  ContainerConfigurationTemplate containerConfigJson =
      JsonTemplateMapper.readJsonFromFile(jsonFile, ContainerConfigurationTemplate.class);

  Assert.assertEquals(
      Arrays.asList("VAR1=VAL1", "VAR2=VAL2"), containerConfigJson.getContainerEnvironment());

  Assert.assertEquals(
      Arrays.asList("some", "entrypoint", "command"),
      containerConfigJson.getContainerEntrypoint());

  Assert.assertEquals(
      DescriptorDigest.fromDigest(
          "sha256:8c662931926fa990b41da3c9f42663a537ccd498130030f9149173a0493832ad"),
      containerConfigJson.getLayerDiffId(0));
}

@Test
public void testToJson() throws DigestException, IOException, URISyntaxException {
  // Loads the expected JSON string.
  Path jsonFile = Paths.get(Resources.getResource("json/v22manifest.json").toURI());
  String expectedJson = new String(Files.readAllBytes(jsonFile), StandardCharsets.UTF_8);

  // Creates the JSON object to serialize.
  V22ManifestTemplate manifestJson = new V22ManifestTemplate();

  manifestJson.setContainerConfiguration(
      1000,
      DescriptorDigest.fromDigest(
          "sha256:8c662931926fa990b41da3c9f42663a537ccd498130030f9149173a0493832ad"));

  manifestJson.addLayer(
      1000_000,
      DescriptorDigest.fromHash(
          "4945ba5011739b0b98c4a41afe224e417f47c7c99b2ce76830999c9a0861b236"));

  // Serializes the JSON object.
  ByteArrayOutputStream jsonStream = new ByteArrayOutputStream();
  JsonTemplateMapper.writeJson(jsonStream, manifestJson);

  Assert.assertEquals(expectedJson, jsonStream.toString());
}

@Test
public void testFromJson() throws IOException, URISyntaxException, DigestException {
  // Loads the JSON string.
  Path jsonFile = Paths.get(Resources.getResource("json/v22manifest.json").toURI());

  // Deserializes into a manifest JSON object.
  V22ManifestTemplate manifestJson =
      JsonTemplateMapper.readJsonFromFile(jsonFile, V22ManifestTemplate.class);

  Assert.assertEquals(
      DescriptorDigest.fromDigest(
          "sha256:8c662931926fa990b41da3c9f42663a537ccd498130030f9149173a0493832ad"),
      manifestJson.getContainerConfigurationDigest());

  Assert.assertEquals(1000, manifestJson.getContainerConfigurationSize());

  Assert.assertEquals(
      DescriptorDigest.fromHash(
          "4945ba5011739b0b98c4a41afe224e417f47c7c99b2ce76830999c9a0861b236"),
      manifestJson.getLayerDigest(0));

  Assert.assertEquals(1000_000, manifestJson.getLayerSize(0));
}

@Before
public void setUp()
    throws DigestException, LayerPropertyNotFoundException, DuplicateLayerException {
  Image testImage = new Image();

  testImage.setEnvironmentVariable("VAR1", "VAL1");
  testImage.setEnvironmentVariable("VAR2", "VAL2");

  testImage.setEntrypoint(Arrays.asList("some", "entrypoint", "command"));

  DescriptorDigest fakeDigest =
      DescriptorDigest.fromDigest(
          "sha256:8c662931926fa990b41da3c9f42663a537ccd498130030f9149173a0493832ad");
  Layer fakeLayer = new ReferenceLayer(new BlobDescriptor(1000, fakeDigest), fakeDigest);
  testImage.addLayer(fakeLayer);

  imageToJsonTranslator = new ImageToJsonTranslator(testImage);
}

@Test
public void testFromJson() throws URISyntaxException, IOException, DigestException {
  // Loads the JSON string.
  Path jsonFile = Paths.get(Resources.getResource("json/v21manifest.json").toURI());

  // Deserializes into a manifest JSON object.
  V21ManifestTemplate manifestJson =
      JsonTemplateMapper.readJsonFromFile(jsonFile, V21ManifestTemplate.class);

  Assert.assertEquals(
      DescriptorDigest.fromDigest(
          "sha256:8c662931926fa990b41da3c9f42663a537ccd498130030f9149173a0493832ad"),
      manifestJson.getLayerDigest(0));

  Assert.assertEquals("some v1-compatible object", manifestJson.getV1Compatibility(0));
}

@Test
public void testToImage_v21()
    throws IOException, LayerPropertyNotFoundException, DuplicateLayerException, DigestException,
        URISyntaxException {
  // Loads the JSON string.
  Path jsonFile =
      Paths.get(getClass().getClassLoader().getResource("json/v21manifest.json").toURI());

  // Deserializes into a manifest JSON object.
  V21ManifestTemplate manifestTemplate =
      JsonTemplateMapper.readJsonFromFile(jsonFile, V21ManifestTemplate.class);

  Image image = JsonToImageTranslator.toImage(manifestTemplate);

  List<Layer> layers = image.getLayers();
  Assert.assertEquals(1, layers.size());
  Assert.assertEquals(
      DescriptorDigest.fromDigest(
          "sha256:8c662931926fa990b41da3c9f42663a537ccd498130030f9149173a0493832ad"),
      layers.get(0).getBlobDescriptor().getDigest());
}

protected void setLessInstances(String key,
                                String format,
                                String fileName,
                                String sourceName,
                                String sourcePath) throws InterruptedException, IOException, NoSuchAlgorithmException, DigestException {
    setPxInstance(key,
            "500",
            format,
            fileName,
            sourceName,
            sourcePath);
    setPxInstance(key,
            "400",
            format,
            fileName,
            sourceName,
            sourcePath);
    setPxInstance(key,
            "200",
            format,
            fileName,
            sourceName,
            sourcePath);
}

private File getSubDirForZip(String[] tokens, String baseZipUrl, String baseSubDir) throws CantLoadMCPMappingException, NoSuchAlgorithmException, DigestException, IOException
{
    if (!baseDir.exists() && !baseDir.mkdirs())
        throw new CantLoadMCPMappingException("Application data folder does not exist and cannot be created.");

    File subDir = new File(baseDir, replaceTokens(baseSubDir, tokens));
    if (!subDir.exists() && !subDir.mkdirs())
        throw new CantLoadMCPMappingException("Data folder does not exist and cannot be created.");

    try {
        RemoteZipHandler rzh = new RemoteZipHandler(replaceTokens(baseZipUrl, tokens), subDir, "SHA1");
        rzh.checkRemoteZip();
    } catch (Throwable t) {
        ASMStackLogger.printStackTrace(t);
    }

    return subDir;
}

/**
 */
protected int engineDigest(byte[] buf, int offset, int len) throws DigestException {
    byte[] result = new byte[CRC32_LENGTH];
    result = int2quad(seed);
    if (len < CRC32_LENGTH) {
        throw new DigestException("partial digests not returned");
    }
    if (buf.length - offset < CRC32_LENGTH) {
        throw new DigestException("insufficient space in the output " +
                                  "buffer to store the digest");
    }
    System.arraycopy(result, 0, buf, offset, CRC32_LENGTH);
    //processBuffer(buffer, 0, bufferIndex, result, 0);
    /*if (len < CRC32_LENGTH) {
      throw new DigestException("partial digests not returned");
      }
      if (buf.length - offset < CRC32_LENGTH) {
      throw new DigestException("insufficient space in the output " +
      "buffer to store the digest");
      }
      System.arraycopy(result, 0, buf, offset, CRC32_LENGTH);      */
    init();
    return CRC32_LENGTH;
}

protected final int engineDigest(byte[] out, int ofs, int len)
        throws DigestException {
    if (len < digestLength) {
        throw new DigestException("Length must be at least "
            + digestLength + " for " + algorithm + "digests");
    }
    if ((ofs < 0) || (len < 0) || (ofs > out.length - len)) {
        throw new DigestException("Buffer too short to store digest");
    }
    if (bytesProcessed < 0) {
        engineReset();
    }
    implDigest(out, ofs);
    bytesProcessed = -1;
    return digestLength;
}

/**
 */
protected int engineDigest(byte[] buf, int offset, int len) throws DigestException {
    byte[] result = new byte[CRC32_LENGTH];
    result = int2quad(seed);
    if (len < CRC32_LENGTH) {
        throw new DigestException("partial digests not returned");
    }
    if (buf.length - offset < CRC32_LENGTH) {
        throw new DigestException("insufficient space in the output " +
                                  "buffer to store the digest");
    }
    System.arraycopy(result, 0, buf, offset, CRC32_LENGTH);
    //processBuffer(buffer, 0, bufferIndex, result, 0);
    /*if (len < CRC32_LENGTH) {
      throw new DigestException("partial digests not returned");
      }
      if (buf.length - offset < CRC32_LENGTH) {
      throw new DigestException("insufficient space in the output " +
      "buffer to store the digest");
      }
      System.arraycopy(result, 0, buf, offset, CRC32_LENGTH);      */
    init();
    return CRC32_LENGTH;
}

protected final int engineDigest(byte[] out, int ofs, int len)
        throws DigestException {
    if (len < digestLength) {
        throw new DigestException("Length must be at least "
            + digestLength + " for " + algorithm + "digests");
    }
    if ((ofs < 0) || (len < 0) || (ofs > out.length - len)) {
        throw new DigestException("Buffer too short to store digest");
    }
    if (bytesProcessed < 0) {
        engineReset();
    }
    implDigest(out, ofs);
    bytesProcessed = -1;
    return digestLength;
}

protected final int engineDigest(byte[] out, int ofs, int len)
        throws DigestException {
    if (len < digestLength) {
        throw new DigestException("Length must be at least "
            + digestLength + " for " + algorithm + "digests");
    }
    if ((ofs < 0) || (len < 0) || (ofs > out.length - len)) {
        throw new DigestException("Buffer too short to store digest");
    }
    if (bytesProcessed < 0) {
        engineReset();
    }
    implDigest(out, ofs);
    bytesProcessed = -1;
    return digestLength;
}

/**
 */
protected int engineDigest(byte[] buf, int offset, int len) throws DigestException {
    byte[] result = new byte[CRC32_LENGTH];
    result = int2quad(seed);
    if (len < CRC32_LENGTH) {
        throw new DigestException("partial digests not returned");
    }
    if (buf.length - offset < CRC32_LENGTH) {
        throw new DigestException("insufficient space in the output " +
                                  "buffer to store the digest");
    }
    System.arraycopy(result, 0, buf, offset, CRC32_LENGTH);
    //processBuffer(buffer, 0, bufferIndex, result, 0);
    /*if (len < CRC32_LENGTH) {
      throw new DigestException("partial digests not returned");
      }
      if (buf.length - offset < CRC32_LENGTH) {
      throw new DigestException("insufficient space in the output " +
      "buffer to store the digest");
      }
      System.arraycopy(result, 0, buf, offset, CRC32_LENGTH);      */
    init();
    return CRC32_LENGTH;
}

protected final int engineDigest(byte[] out, int ofs, int len)
        throws DigestException {
    if (len < digestLength) {
        throw new DigestException("Length must be at least "
            + digestLength + " for " + algorithm + "digests");
    }
    if ((ofs < 0) || (len < 0) || (ofs > out.length - len)) {
        throw new DigestException("Buffer too short to store digest");
    }
    if (bytesProcessed < 0) {
        engineReset();
    }
    implDigest(out, ofs);
    bytesProcessed = -1;
    return digestLength;
}

/**
 * A hash-based derivation function defined in NIST SP 800-90Ar1 10.3.1.
 * The function is used inside Hash_DRBG, and can also be used as an
 * approved conditioning function as described in 800-90B 6.4.2.2.
 *
 * @param digest a {@code MessageDigest} object in reset state
 * @param outLen {@link MessageDigest#getDigestLength} of {@code digest}
 * @param requested requested output length, in bytes
 * @param inputs input data
 * @return the condensed/expanded output
 */
public static byte[] hashDf(MessageDigest digest, int outLen,
                            int requested, byte[]... inputs) {
    int len = (requested + outLen - 1) / outLen;
    byte[] temp = new byte[len * outLen];
    int counter = 1;

    for (int i=0; i<len; i++) {
        digest.update((byte) counter);
        digest.update((byte)(requested >> 21)); // requested*8 as int32
        digest.update((byte)(requested >> 13));
        digest.update((byte)(requested >> 5));
        digest.update((byte)(requested << 3));
        for (byte[] input : inputs) {
            digest.update(input);
        }
        try {
            digest.digest(temp, i * outLen, outLen);
        } catch (DigestException e) {
            throw new AssertionError("will not happen", e);
        }
        counter++;
    }
    return temp.length == requested? temp: Arrays.copyOf(temp, requested);
}

/**
 */
protected int engineDigest(byte[] buf, int offset, int len) throws DigestException {
    byte[] result = new byte[CRC32_LENGTH];
    result = int2quad(seed);
    if (len < CRC32_LENGTH) {
        throw new DigestException("partial digests not returned");
    }
    if (buf.length - offset < CRC32_LENGTH) {
        throw new DigestException("insufficient space in the output " +
                                  "buffer to store the digest");
    }
    System.arraycopy(result, 0, buf, offset, CRC32_LENGTH);
    //processBuffer(buffer, 0, bufferIndex, result, 0);
    /*if (len < CRC32_LENGTH) {
      throw new DigestException("partial digests not returned");
      }
      if (buf.length - offset < CRC32_LENGTH) {
      throw new DigestException("insufficient space in the output " +
      "buffer to store the digest");
      }
      System.arraycopy(result, 0, buf, offset, CRC32_LENGTH);      */
    init();
    return CRC32_LENGTH;
}

public void run() throws DigestException {
  System.err.println(home + " starting");
  synchronized (this) {
    state = -1;
  }
  while (bag.size > 0) {
    while (bag.size > 0) {
      for (int n = 500; (n > 0) && (bag.size > 0); --n) {
        bag.expand(md);
      }
      distribute();
    }
    steal();
  }
  synchronized (this) {
    state = -2;
  }
  distribute();
  lifelinesteal();
  System.err.println(home + " stopping");
}

private void digest(MessageDigest md, int d) throws DigestException {
  if (size >= depth.length) {
    grow();
  }
  ++count;
  final int offset = size * 20;
  md.digest(hash, offset, 20);
  final int v = ((0x7f & hash[offset + 16]) << 24)
      | ((0xff & hash[offset + 17]) << 16) | ((0xff & hash[offset + 18]) << 8)
      | (0xff & hash[offset + 19]);
  final int n = (int) (Math.log(1.0 - v / 2147483648.0) / den);
  if (n > 0) {
    if (d > 1) {
      depth[size] = d - 1;
      lower[size] = 0;
      upper[size++] = n;
    } else {
      count += n;
    }
  }
}

public void expand(MessageDigest md) throws DigestException {
  final int top = size - 1;
  final int d = depth[top];
  final int l = lower[top];
  final int u = upper[top] - 1;
  if (u == l) {
    size = top;
  } else {
    upper[top] = u;
  }
  final int offset = top * 20;
  hash[offset + 20] = (byte) (u >> 24);
  hash[offset + 21] = (byte) (u >> 16);
  hash[offset + 22] = (byte) (u >> 8);
  hash[offset + 23] = (byte) u;
  md.update(hash, offset, 24);
  digest(md, d);
}

@Override
protected int engineDigest(byte[] buf, int offset, int len) throws DigestException
{
    if (len < 32)
        throw new DigestException("Invalid digest length for SHA256");
    if (posn <= (64 - 9)) {
        block[posn] = (byte)0x80;
        Arrays.fill(block, posn + 1, 64 - 8, (byte)0);
    } else {
        block[posn] = (byte)0x80;
        Arrays.fill(block, posn + 1, 64, (byte)0);
        transform(block, 0);
        Arrays.fill(block, 0, 64 - 8, (byte)0);
    }
    writeBE32(block, 64 - 8, (int)(length >> 32));
    writeBE32(block, 64 - 4, (int)length);
    transform(block, 0);
    posn = 0;
    for (int index = 0; index < 8; ++index)
        writeBE32(buf, offset + index * 4, h[index]);
    return 32;
}

@Override
protected int engineDigest(byte[] buf, int offset, int len) throws DigestException
{
    if (len < 64)
        throw new DigestException("Invalid digest length for BLAKE2b");
    Arrays.fill(block, posn, 128, (byte)0);
    transform(-1);
    for (int index = 0; index < 8; ++index) {
        long value = h[index];
        buf[offset++] = (byte)value;
        buf[offset++] = (byte)(value >> 8);
        buf[offset++] = (byte)(value >> 16);
        buf[offset++] = (byte)(value >> 24);
        buf[offset++] = (byte)(value >> 32);
        buf[offset++] = (byte)(value >> 40);
        buf[offset++] = (byte)(value >> 48);
        buf[offset++] = (byte)(value >> 56);
    }
    return 32;
}

@Override
protected int engineDigest(byte[] buf, int offset, int len) throws DigestException
{
    if (len < 32)
        throw new DigestException("Invalid digest length for BLAKE2s");
    Arrays.fill(block, posn, 64, (byte)0);
    transform(-1);
    for (int index = 0; index < 8; ++index) {
        int value = h[index];
        buf[offset++] = (byte)value;
        buf[offset++] = (byte)(value >> 8);
        buf[offset++] = (byte)(value >> 16);
        buf[offset++] = (byte)(value >> 24);
    }
    return 32;
}

@Override
protected int engineDigest(byte[] buf, int offset, int len) throws DigestException
{
    if (len < 64)
        throw new DigestException("Invalid digest length for SHA512");
    if (posn <= (128 - 17)) {
        block[posn] = (byte)0x80;
        Arrays.fill(block, posn + 1, 128 - 8, (byte)0);
    } else {
        block[posn] = (byte)0x80;
        Arrays.fill(block, posn + 1, 128, (byte)0);
        transform(block, 0);
        Arrays.fill(block, 0, 128 - 8, (byte)0);
    }
    writeBE64(block, 128 - 8, length);
    transform(block, 0);
    posn = 0;
    for (int index = 0; index < 8; ++index)
        writeBE64(buf, offset + index * 8, h[index]);
    return 64;
}

/**
 */
protected int engineDigest(byte[] buf, int offset, int len) throws DigestException {
    byte[] result = new byte[CRC32_LENGTH];
    result = int2quad(seed);
    if (len < CRC32_LENGTH) {
        throw new DigestException("partial digests not returned");
    }
    if (buf.length - offset < CRC32_LENGTH) {
        throw new DigestException("insufficient space in the output " +
                                  "buffer to store the digest");
    }
    System.arraycopy(result, 0, buf, offset, CRC32_LENGTH);
    //processBuffer(buffer, 0, bufferIndex, result, 0);
    /*if (len < CRC32_LENGTH) {
      throw new DigestException("partial digests not returned");
      }
      if (buf.length - offset < CRC32_LENGTH) {
      throw new DigestException("insufficient space in the output " +
      "buffer to store the digest");
      }
      System.arraycopy(result, 0, buf, offset, CRC32_LENGTH);      */
    init();
    return CRC32_LENGTH;
}

protected final int engineDigest(byte[] out, int ofs, int len)
        throws DigestException {
    if (len < digestLength) {
        throw new DigestException("Length must be at least "
            + digestLength + " for " + algorithm + "digests");
    }
    if ((ofs < 0) || (len < 0) || (ofs > out.length - len)) {
        throw new DigestException("Buffer too short to store digest");
    }
    if (bytesProcessed < 0) {
        engineReset();
    }
    implDigest(out, ofs);
    bytesProcessed = -1;
    return digestLength;
}

/**
 */
protected int engineDigest(byte[] buf, int offset, int len) throws DigestException {
    byte[] result = new byte[CRC32_LENGTH];
    result = int2quad(seed);
    if (len < CRC32_LENGTH) {
        throw new DigestException("partial digests not returned");
    }
    if (buf.length - offset < CRC32_LENGTH) {
        throw new DigestException("insufficient space in the output " +
                                  "buffer to store the digest");
    }
    System.arraycopy(result, 0, buf, offset, CRC32_LENGTH);
    //processBuffer(buffer, 0, bufferIndex, result, 0);
    /*if (len < CRC32_LENGTH) {
      throw new DigestException("partial digests not returned");
      }
      if (buf.length - offset < CRC32_LENGTH) {
      throw new DigestException("insufficient space in the output " +
      "buffer to store the digest");
      }
      System.arraycopy(result, 0, buf, offset, CRC32_LENGTH);      */
    init();
    return CRC32_LENGTH;
}

protected final int engineDigest(byte[] out, int ofs, int len)
        throws DigestException {
    if (len < digestLength) {
        throw new DigestException("Length must be at least "
            + digestLength + " for " + algorithm + "digests");
    }
    if ((ofs < 0) || (len < 0) || (ofs > out.length - len)) {
        throw new DigestException("Buffer too short to store digest");
    }
    if (bytesProcessed < 0) {
        engineReset();
    }
    implDigest(out, ofs);
    bytesProcessed = -1;
    return digestLength;
}

/**
 * Test using resource data.
 * <p>
 * Format: SHA-256 digest | LZFSE encoded data
 * <p>
 * lzfse.test: contains bvx-, bvx1, bvx2, bvxn encrypted random words (text)
 *
 * @throws IOException
 * @throws java.security.NoSuchAlgorithmException
 * @throws java.security.DigestException
 */
@Test
public void defaultTest() throws IOException, NoSuchAlgorithmException, DigestException {
    InputStream is = this.getClass().getClassLoader().getResourceAsStream("lzfse.test");
    assertNotNull("lzfse.test", is);

    byte[] digest = new byte[32];
    is.read(digest);

    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    try (InputStream dis = new LZFSEInputStream(is)) {
        copy(dis, baos, buffer);
    }

    MessageDigest md = MessageDigest.getInstance("SHA-256");
    byte[] _digest = md.digest(baos.toByteArray());

    assertArrayEquals("SHA-256", digest, _digest);
}

private Cipher getCipher(int cipherMode) throws NoSuchAlgorithmException,
        NoSuchPaddingException, InvalidKeyException,
        InvalidAlgorithmParameterException, DigestException {

    Cipher cipher = Cipher.getInstance(this.cipherTransformation);

    // calculate a file specific IV based on the unique relative filename
    byte[] iv = new byte[cipher.getBlockSize()];
    MessageDigest md = MessageDigest.getInstance("MD5");
    md.update(this.relativeFilename.getBytes());
    md.digest(iv, 0, cipher.getBlockSize());
    IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);

    // load the mode, symmetric key and IV into the Cipher
    cipher.init(cipherMode, this.secretKeySpec, ivParameterSpec);
    return cipher;

}

/**
 * Generating private key. Source: https://cr.yp.to/ecdh.html
 *
 * @param randomBytes random bytes (32+ bytes)
 * @return generated private key
 */
public static byte[] keyGenPrivate(byte[] randomBytes) throws NoSuchAlgorithmException, DigestException {

    if (randomBytes.length < 32) {
        throw new RuntimeException("Random bytes too small");
    }

    // Hashing Random Bytes instead of using random bytes directly
    // Just in case as reference ed255519 implementation do same
    MessageDigest digest = MessageDigest.getInstance("SHA-256");
    digest.digest(randomBytes, 0, randomBytes.length);
    byte[] privateKey = digest.digest();

    // Performing bit's flipping
    privateKey[0] &= 248;
    privateKey[31] &= 127;
    privateKey[31] |= 64;

    return privateKey;
}

public static void main(String[] args) throws DigestException, NoSuchAlgorithmException, IOException {
    SecureRandom secureRandom = new SecureRandom();
    if (!new File("keys").exists()) {
        new File("keys").mkdir();
    }
    for (int i = 0; i < 4; i++) {
        File pubFile = new File("keys/actor-key-" + i + ".pub");
        File keyFile = new File("keys/actor-key-" + i + ".key");
        if (pubFile.exists() && keyFile.exists()) {
            System.out.println("Key #" + i + " exists. Skipping...");
            continue;
        }
        Curve25519KeyPair keyPair = Curve25519.keyGen(secureRandom.generateSeed(64));
        FileUtils.writeByteArrayToFile(pubFile, keyPair.getPublicKey());
        FileUtils.writeByteArrayToFile(keyFile, keyPair.getPrivateKey());
    }
    System.out.println("Shared Secret: " + Base64.getEncoder().encodeToString(secureRandom.generateSeed(64)));
}

/**
 */
protected int engineDigest(byte[] buf, int offset, int len) throws DigestException {
    byte[] result = new byte[CRC32_LENGTH];
    result = int2quad(seed);
    if (len < CRC32_LENGTH) {
        throw new DigestException("partial digests not returned");
    }
    if (buf.length - offset < CRC32_LENGTH) {
        throw new DigestException("insufficient space in the output " +
                                  "buffer to store the digest");
    }
    System.arraycopy(result, 0, buf, offset, CRC32_LENGTH);
    //processBuffer(buffer, 0, bufferIndex, result, 0);
    /*if (len < CRC32_LENGTH) {
      throw new DigestException("partial digests not returned");
      }
      if (buf.length - offset < CRC32_LENGTH) {
      throw new DigestException("insufficient space in the output " +
      "buffer to store the digest");
      }
      System.arraycopy(result, 0, buf, offset, CRC32_LENGTH);      */
    init();
    return CRC32_LENGTH;
}