• Home
• org.signal
• libsignal-client
• 0.58.2
• source code
• Native.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.signal.libsignal.internal.Native Maven / Gradle / Ivy

//
// Copyright (C) 2020-2021 Signal Messenger, LLC.
// SPDX-License-Identifier: AGPL-3.0-only
//

// WARNING: this file was automatically generated

package org.signal.libsignal.internal;

import org.signal.libsignal.protocol.message.CiphertextMessage;
import org.signal.libsignal.protocol.state.IdentityKeyStore;
import org.signal.libsignal.protocol.state.SessionStore;
import org.signal.libsignal.protocol.state.PreKeyStore;
import org.signal.libsignal.protocol.state.SignedPreKeyStore;
import org.signal.libsignal.protocol.state.KyberPreKeyStore;
import org.signal.libsignal.protocol.groups.state.SenderKeyStore;
import org.signal.libsignal.protocol.logging.Log;
import org.signal.libsignal.protocol.logging.SignalProtocolLogger;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.concurrent.Future;
import java.util.UUID;
import java.util.Map;

public final class Native {
  private static Path tempDir;

  private static void copyToTempDirAndLoad(InputStream in, String name) throws IOException {
    // This isn't thread-safe but that's okay because it's only ever called from
    // static initializers, which are themselves thread-safe.
    if (tempDir == null) {
      tempDir = Files.createTempDirectory("libsignal");
      tempDir.toFile().deleteOnExit();
    }

    File tempFile = Files.createFile(tempDir.resolve(name)).toFile();
    tempFile.deleteOnExit();

    try (OutputStream out = new FileOutputStream(tempFile)) {
      byte[] buffer = new byte[4096];
      int read;

      while ((read = in.read(buffer)) != -1) {
        out.write(buffer, 0, read);
      }
    }
    System.load(tempFile.getAbsolutePath());
  }

  /**
   * If the library is embedded within this jar as a resource file, attempt to
   * copy it to a temporary file and then load it. This allows the jar to be
   * used even without a shared library existing on the filesystem.
   *
   * If a version of the library that includes this system's hardware architecture in its name is
   * present, prefer that to the supplied name (e.g. "libsignal_amd64.so" will be preferred to
   * "libsignal.so"). This applies only to libraries embedded as a resource, not libraries
   * installed on the local machine.
   *
   * Package-private to allow the NativeTest class to load its shared library.
   * This method should only be called from a static initializer.
   */
  static void loadLibrary(String name) throws IOException {
    String arch = System.getProperty("os.arch");
    // Special-case: some Java implementations use "x86_64", but OpenJDK uses "amd64".
    if ("x86_64".equals(arch)) {
      arch = "amd64";
    }
    for (String suffix : new String[]{ "_" + arch, "" }) {
      final String libraryName = System.mapLibraryName(name + suffix);
      try (InputStream in = Native.class.getResourceAsStream("/" + libraryName)) {
        if (in != null) {
          copyToTempDirAndLoad(in, libraryName);
          return;
        }
      }
    }
    System.loadLibrary(name);
  }

  private static void loadNativeCode() {
    try {
      loadLibrary("signal_jni");
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  static {
    loadNativeCode();
    initializeLibrary();
  }

  private Native() {}

  /**
   * Keeps an object from being garbage-collected until this call completes.
   *
   * This can be used to keep a Java wrapper around a Rust object handle alive while
   * earlier calls use that Rust object handle. That is, you should call {@code keepAlive} 
   * after the code where an object must not be garbage-collected.
   * However, most of the time {@link NativeHandleGuard} is a better choice,
   * since the lifetime of the guard is clear.
   *
   * Effectively equivalent to Java 9's reachabilityFence().
   * Uses {@code native} because the JVM can't look into the implementation of the method
   * and optimize away the use of {@code obj}. (The actual implementation does nothing.)
   */
  public static native void keepAlive(Object obj);

  public static native String AccountEntropyPool_Generate();

  public static native void Aes256Ctr32_Destroy(long handle);
  public static native long Aes256Ctr32_New(byte[] key, byte[] nonce, int initialCtr) throws Exception;
  public static native void Aes256Ctr32_Process(long ctr, byte[] data, int offset, int length);

  public static native void Aes256GcmDecryption_Destroy(long handle);
  public static native long Aes256GcmDecryption_New(byte[] key, byte[] nonce, byte[] associatedData) throws Exception;
  public static native void Aes256GcmDecryption_Update(long gcm, byte[] data, int offset, int length);
  public static native boolean Aes256GcmDecryption_VerifyTag(long gcm, byte[] tag) throws Exception;

  public static native byte[] Aes256GcmEncryption_ComputeTag(long gcm);
  public static native void Aes256GcmEncryption_Destroy(long handle);
  public static native long Aes256GcmEncryption_New(byte[] key, byte[] nonce, byte[] associatedData) throws Exception;
  public static native void Aes256GcmEncryption_Update(long gcm, byte[] data, int offset, int length);

  public static native byte[] Aes256GcmSiv_Decrypt(long aesGcmSiv, byte[] ctext, byte[] nonce, byte[] associatedData) throws Exception;
  public static native void Aes256GcmSiv_Destroy(long handle);
  public static native byte[] Aes256GcmSiv_Encrypt(long aesGcmSivObj, byte[] ptext, byte[] nonce, byte[] associatedData) throws Exception;
  public static native long Aes256GcmSiv_New(byte[] key) throws Exception;

  public static native Object AsyncLoadClass(Object tokioContext, String className);

  public static native void AuthChat_Destroy(long handle);

  public static native void AuthCredentialPresentation_CheckValidContents(byte[] presentationBytes) throws Exception;
  public static native byte[] AuthCredentialPresentation_GetPniCiphertext(byte[] presentationBytes);
  public static native long AuthCredentialPresentation_GetRedemptionTime(byte[] presentationBytes);
  public static native byte[] AuthCredentialPresentation_GetUuidCiphertext(byte[] presentationBytes);

  public static native void AuthCredentialWithPniResponse_CheckValidContents(byte[] bytes) throws Exception;

  public static native void AuthCredentialWithPni_CheckValidContents(byte[] bytes) throws Exception;

  public static native void BackupAuthCredentialPresentation_CheckValidContents(byte[] presentationBytes) throws Exception;
  public static native byte[] BackupAuthCredentialPresentation_GetBackupId(byte[] presentationBytes);
  public static native int BackupAuthCredentialPresentation_GetBackupLevel(byte[] presentationBytes);
  public static native void BackupAuthCredentialPresentation_Verify(byte[] presentationBytes, long now, byte[] serverParamsBytes) throws Exception;

  public static native void BackupAuthCredentialRequestContext_CheckValidContents(byte[] contextBytes) throws Exception;
  public static native byte[] BackupAuthCredentialRequestContext_GetRequest(byte[] contextBytes);
  public static native byte[] BackupAuthCredentialRequestContext_New(byte[] backupKey, UUID uuid);
  public static native byte[] BackupAuthCredentialRequestContext_ReceiveResponse(byte[] contextBytes, byte[] responseBytes, long expectedRedemptionTime, byte[] paramsBytes) throws Exception;

  public static native void BackupAuthCredentialRequest_CheckValidContents(byte[] requestBytes) throws Exception;
  public static native byte[] BackupAuthCredentialRequest_IssueDeterministic(byte[] requestBytes, long redemptionTime, int backupLevel, byte[] paramsBytes, byte[] randomness);

  public static native void BackupAuthCredentialResponse_CheckValidContents(byte[] responseBytes) throws Exception;

  public static native void BackupAuthCredential_CheckValidContents(byte[] paramsBytes) throws Exception;
  public static native byte[] BackupAuthCredential_GetBackupId(byte[] credentialBytes);
  public static native int BackupAuthCredential_GetBackupLevel(byte[] credentialBytes);
  public static native byte[] BackupAuthCredential_PresentDeterministic(byte[] credentialBytes, byte[] serverParamsBytes, byte[] randomness) throws Exception;

  public static native void CallLinkAuthCredentialPresentation_CheckValidContents(byte[] presentationBytes) throws Exception;
  public static native byte[] CallLinkAuthCredentialPresentation_GetUserId(byte[] presentationBytes);
  public static native void CallLinkAuthCredentialPresentation_Verify(byte[] presentationBytes, long now, byte[] serverParamsBytes, byte[] callLinkParamsBytes) throws Exception;

  public static native void CallLinkAuthCredentialResponse_CheckValidContents(byte[] responseBytes) throws Exception;
  public static native byte[] CallLinkAuthCredentialResponse_IssueDeterministic(byte[] userId, long redemptionTime, byte[] paramsBytes, byte[] randomness);
  public static native byte[] CallLinkAuthCredentialResponse_Receive(byte[] responseBytes, byte[] userId, long redemptionTime, byte[] paramsBytes) throws Exception;

  public static native void CallLinkAuthCredential_CheckValidContents(byte[] credentialBytes) throws Exception;
  public static native byte[] CallLinkAuthCredential_PresentDeterministic(byte[] credentialBytes, byte[] userId, long redemptionTime, byte[] serverParamsBytes, byte[] callLinkParamsBytes, byte[] randomness) throws Exception;

  public static native void CallLinkPublicParams_CheckValidContents(byte[] paramsBytes) throws Exception;

  public static native void CallLinkSecretParams_CheckValidContents(byte[] paramsBytes) throws Exception;
  public static native byte[] CallLinkSecretParams_DecryptUserId(byte[] paramsBytes, byte[] userId) throws Exception;
  public static native byte[] CallLinkSecretParams_DeriveFromRootKey(byte[] rootKey);
  public static native byte[] CallLinkSecretParams_GetPublicParams(byte[] paramsBytes);

  public static native long Cds2ClientState_New(byte[] mrenclave, byte[] attestationMsg, long currentTimestamp) throws Exception;

  public static native Map Cds2Metrics_extract(byte[] attestationMsg) throws Exception;

  public static native void CdsiLookup_Destroy(long handle);
  public static native CompletableFuture