Java KeyHelper类代码示例

import org.whispersystems.libsignal.util.KeyHelper; //导入依赖的package包/类
/**
 * Finish the connection and registration as primary device with the received verification code
 * @param verificationCode the verification code without the -
 * @throws IOException
 */
public void finishConnectAsPrimary(String verificationCode) throws IOException {
	if(accountManager == null) {
		throw new IllegalStateException("Cannot finish: No connection started!");
	} else if(isRegistered()) {
		throw new IllegalStateException("Already registered!");
	}
	createRegistrationId();
	accountManager.verifyAccountWithCode(verificationCode, store.getSignalingKey(), 
			store.getLocalRegistrationId(), false, true);
	IdentityKeyPair identityKeyPair = KeyHelper.generateIdentityKeyPair();
	store.setIdentityKeyPair(identityKeyPair);
	store.setLastResortPreKey(KeyHelper.generateLastResortPreKey());
	checkPreKeys(-1);
	save();
}
 

import org.whispersystems.libsignal.util.KeyHelper; //导入依赖的package包/类
/**
 * Blocking call. Call this directly after {@code startConnectAsSecondary()} and this method will wait
 * for the master device accepting this device.
 * @param deviceName a name for this device (not the user agent)
 * @param supportsSms whether this device can receive and send SMS
 * @throws IOException
 * @throws TimeoutException
 */
public void finishConnectAsSecondary(String deviceName, boolean supportsSms) throws IOException, TimeoutException {
	if(accountManager == null) {
		throw new IllegalStateException("Cannot finish: No connection started!");
	} else if(isRegistered()) {
		throw new IllegalStateException("Already registered!");
	}
	try {
		NewDeviceRegistrationReturn ret = accountManager.finishNewDeviceRegistration(tempIdentity,
				store.getSignalingKey(), supportsSms, true, store.getLocalRegistrationId(), deviceName);
		store.setDeviceId(ret.getDeviceId());
		store.setIdentityKeyPair(ret.getIdentity());
	} catch (InvalidKeyException e) {
		throw new RuntimeException("This can not happen - theoretically", e);
	}
	store.setLastResortPreKey(KeyHelper.generateLastResortPreKey());
	checkPreKeys(-1);
	save();
}
 

import org.whispersystems.libsignal.util.KeyHelper; //导入依赖的package包/类
public void getQrCode(Consumer<String> callback) {
	executor.submit(new Runnable() {
		@Override
		public void run() {
			try {
				logger.debug("Creating QR code for provisioning");
				temporaryPassword = SecretUtil.getSecret(18);
				temporaryIdentity = KeyHelper.generateIdentityKeyPair();
				accountManager = new SignalServiceAccountManager(SignalConstants.URL, new ResourceTrustStore(),
						null, temporaryPassword, SignalConstants.USER_AGENT);

				String uuid = accountManager.getNewDeviceUuid();
				String publicKey = Base64.encodeBytesWithoutPadding(temporaryIdentity.getPublicKey().serialize());
				String qrString = "tsdevice:/?uuid=" + URLEncoder.encode(uuid, "UTF-8") + "&pub_key="
						+ URLEncoder.encode(publicKey, "UTF-8");
				logger.debug("Content of qr code: {}", qrString);

				String qrCode = QRCode.from(qrString).file().getAbsolutePath();
				callback.accept(qrCode);
			} catch (IOException | TimeoutException e) {
				throw new RuntimeException("Networking error while creating provisioning QR code!", e);
			}
		}
	});
}
 

import org.whispersystems.libsignal.util.KeyHelper; //导入依赖的package包/类
public void finishRegistration(String deviceName, Consumer<Void> callback) {
	executor.submit(new Runnable() {
		@Override
		public void run() {
			String temporarySignalingKey = SecretUtil.getSecret(52);
			int temporaryRegistrationId = KeyHelper.generateRegistrationId(false);
			try {
				NewDeviceRegistrationReturn ret = accountManager.finishNewDeviceRegistration(temporaryIdentity,
						temporarySignalingKey, false, true, temporaryRegistrationId, deviceName);
				logger.debug("Got response from master device for provisioning");
				Main.getInstance().getStore().getUserStore().createNewIdentity(ret.getNumber(), ret.getDeviceId(),
						temporaryPassword, temporaryRegistrationId, temporarySignalingKey, temporaryIdentity);
				callback.accept(null);
			} catch (TimeoutException | IOException | InvalidKeyException e) {
				e.printStackTrace();
				throw new RuntimeException("Could not finish device registration!", e);
			}

		}
	});
}
 

import org.whispersystems.libsignal.util.KeyHelper; //导入依赖的package包/类
/**
 * Initiate a new session by sending an initial KeyExchangeMessage to the recipient.
 *
 * @return the KeyExchangeMessage to deliver.
 */
public KeyExchangeMessage process() {
  synchronized (SessionCipher.SESSION_LOCK) {
    try {
      int             sequence         = KeyHelper.getRandomSequence(65534) + 1;
      int             flags            = KeyExchangeMessage.INITIATE_FLAG;
      ECKeyPair       baseKey          = Curve.generateKeyPair();
      ECKeyPair       ratchetKey       = Curve.generateKeyPair();
      IdentityKeyPair identityKey      = identityKeyStore.getIdentityKeyPair();
      byte[]          baseKeySignature = Curve.calculateSignature(identityKey.getPrivateKey(), baseKey.getPublicKey().serialize());
      SessionRecord   sessionRecord    = sessionStore.loadSession(remoteAddress);

      sessionRecord.getSessionState().setPendingKeyExchange(sequence, baseKey, ratchetKey, identityKey);
      sessionStore.storeSession(remoteAddress, sessionRecord);

      return new KeyExchangeMessage(CiphertextMessage.CURRENT_VERSION,
                                    sequence, flags, baseKey.getPublicKey(), baseKeySignature,
                                    ratchetKey.getPublicKey(), identityKey.getPublicKey());
    } catch (InvalidKeyException e) {
      throw new AssertionError(e);
    }
  }
}
 

import org.whispersystems.libsignal.util.KeyHelper; //导入依赖的package包/类
/**
 * Construct a group session for sending messages.
 *
 * @param senderKeyName The (groupId, senderId, deviceId) tuple.  In this case, 'senderId' should be the caller.
 * @return A SenderKeyDistributionMessage that is individually distributed to each member of the group.
 */
public SenderKeyDistributionMessage create(SenderKeyName senderKeyName) {
  synchronized (GroupCipher.LOCK) {
    try {
      SenderKeyRecord senderKeyRecord = senderKeyStore.loadSenderKey(senderKeyName);

      if (senderKeyRecord.isEmpty()) {
        senderKeyRecord.setSenderKeyState(KeyHelper.generateSenderKeyId(),
                                          0,
                                          KeyHelper.generateSenderKey(),
                                          KeyHelper.generateSenderSigningKey());
        senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
      }

      SenderKeyState state = senderKeyRecord.getSenderKeyState();

      return new SenderKeyDistributionMessage(state.getKeyId(),
                                              state.getSenderChainKey().getIteration(),
                                              state.getSenderChainKey().getSeed(),
                                              state.getSigningKeyPublic());

    } catch (InvalidKeyIdException | InvalidKeyException e) {
      throw new AssertionError(e);
    }
  }
}
 

import org.whispersystems.libsignal.util.KeyHelper; //导入依赖的package包/类
/**
 * Ensures that there are enough prekeys available. Has to be called regularly.<br>
 * Every time somebody sends you a message, he uses one of your prekeys which you have uploaded earlier.
 * To always have one prekey available, you also upload a last resort key. You should always
 * have enough prekeys to prevent key reusing.
 * @param minimumKeys the minimum amount of keys to register. Must be below 100.
 * @throws IOException
 */
public void checkPreKeys(int minimumKeys) throws IOException {
	if(minimumKeys > PREKEYS_BATCH_SIZE) {
		throw new IllegalArgumentException("PreKeys count must be below or equal to " + PREKEYS_BATCH_SIZE);
	}
	checkRegistered();
	int preKeysCount = accountManager.getPreKeysCount();
	if(preKeysCount < minimumKeys || minimumKeys < 0) {
		try {
			// generate prekeys
			int nextPreKeyId = store.getNextPreKeyId();
			ArrayList<PreKeyRecord> preKeys = new ArrayList<>();
			for(int i = 0; i < PREKEYS_BATCH_SIZE; i++) {
				PreKeyRecord record = new PreKeyRecord(nextPreKeyId, Curve.generateKeyPair());
				store.storePreKey(record.getId(), record);
				preKeys.add(record);
				nextPreKeyId = (nextPreKeyId + 1) % MAX_PREKEY_ID;
			}
			store.setNextPreKeyId(nextPreKeyId);
			
			// generate signed prekey
			int nextSignedPreKeyId = store.getNextSignedPreKeyId();
			SignedPreKeyRecord signedPreKey = KeyHelper.generateSignedPreKey(store.getIdentityKeyPair(), nextSignedPreKeyId);
			store.storeSignedPreKey(signedPreKey.getId(), signedPreKey);
			store.setNextSignedPreKeyId((nextSignedPreKeyId + 1) % MAX_PREKEY_ID);
			
			// upload
			accountManager.setPreKeys(store.getIdentityKeyPair().getPublicKey(), store.getLastResortPreKey(), 
					signedPreKey, preKeys);
		} catch (InvalidKeyException e) {
			throw new RuntimeException("Stored identity corrupt!", e);
		}
		save();
	}
}
 

import org.whispersystems.libsignal.util.KeyHelper; //导入依赖的package包/类
public void createNewIdentity() {
    IdentityKeyPair identityKey = KeyHelper.generateIdentityKeyPair();
    int registrationId = KeyHelper.generateRegistrationId(false);
    signalProtocolStore = new JsonSignalProtocolStore(identityKey, registrationId);
    groupStore = new JsonGroupStore();
    registered = false;
    save();
}
 

import org.whispersystems.libsignal.util.KeyHelper; //导入依赖的package包/类
private void handleSmsRegistrationIntent(Intent intent) {
  markAsVerifying(true);

  String  number         = intent.getStringExtra(NUMBER_EXTRA);
  boolean supportsGcm    = intent.getBooleanExtra(GCM_SUPPORTED_EXTRA, true);
  int     registrationId = TextSecurePreferences.getLocalRegistrationId(this);
  boolean supportsVideo  = TextSecurePreferences.isWebrtcCallingEnabled(this) || !supportsGcm;

  if (registrationId == 0) {
    registrationId = KeyHelper.generateRegistrationId(false);
    TextSecurePreferences.setLocalRegistrationId(this, registrationId);
  }

  String password     = Util.getSecret(18);
  String signalingKey = Util.getSecret(52);

  try {
    initializeChallengeListener();

    setState(new RegistrationState(RegistrationState.STATE_CONNECTING, number));
    SignalServiceAccountManager accountManager = AccountManagerFactory.createManager(this, number, password);
    accountManager.requestSmsVerificationCode();

    setState(new RegistrationState(RegistrationState.STATE_VERIFYING, number));
    String challenge = waitForChallenge();
    accountManager.verifyAccountWithCode(challenge, signalingKey, registrationId, true, supportsVideo, !supportsGcm);

    handleCommonRegistration(accountManager, number, password, signalingKey, supportsGcm);
    markAsVerified(number, password, signalingKey);

    setState(new RegistrationState(RegistrationState.STATE_COMPLETE, number));
    broadcastComplete(true);
  } catch (ExpectationFailedException efe) {
    Log.w("RegistrationService", efe);
    setState(new RegistrationState(RegistrationState.STATE_MULTI_REGISTERED, number));
    broadcastComplete(false);
  } catch (UnsupportedOperationException uoe) {
    Log.w("RegistrationService", uoe);
    setState(new RegistrationState(RegistrationState.STATE_GCM_UNSUPPORTED, number));
    broadcastComplete(false);
  } catch (AccountVerificationTimeoutException avte) {
    Log.w("RegistrationService", avte);
    setState(new RegistrationState(RegistrationState.STATE_TIMEOUT, number, password));
    broadcastComplete(false);
  } catch (IOException e) {
    Log.w("RegistrationService", e);
    setState(new RegistrationState(RegistrationState.STATE_NETWORK_ERROR, number));
    broadcastComplete(false);
  } finally {
    shutdownChallengeListener();
  }
}
 

import org.whispersystems.libsignal.util.KeyHelper; //导入依赖的package包/类
private void handleSmsRegistrationIntent(Intent intent) {
  markAsVerifying(true);

  String  number         = intent.getStringExtra(NUMBER_EXTRA);
  boolean supportsGcm    = false;
  int     registrationId = KeyHelper.generateRegistrationId(false);
  TextSecurePreferences.setLocalRegistrationId(this, registrationId);
  SessionUtil.archiveAllSessions(this);

  try {
    String password     = Util.getSecret(18);
    String signalingKey = Util.getSecret(52);

    initializeChallengeListener();

    setState(new RegistrationState(RegistrationState.STATE_CONNECTING, number));
    SignalServiceAccountManager accountManager = AccountManagerFactory.createManager(this, number, password);
    accountManager.requestSmsVerificationCode();

    setState(new RegistrationState(RegistrationState.STATE_VERIFYING, number));
    String challenge = waitForChallenge();
    accountManager.verifyAccountWithCode(challenge, signalingKey, registrationId, !supportsGcm);

    handleCommonRegistration(accountManager, number, password, signalingKey, supportsGcm);
    markAsVerified(number, password, signalingKey);

    setState(new RegistrationState(RegistrationState.STATE_COMPLETE, number));
    broadcastComplete(true);
  } catch (ExpectationFailedException efe) {
    Log.w("RegistrationService", efe);
    setState(new RegistrationState(RegistrationState.STATE_MULTI_REGISTERED, number));
    broadcastComplete(false);
  } catch (UnsupportedOperationException uoe) {
    Log.w("RegistrationService", uoe);
    setState(new RegistrationState(RegistrationState.STATE_GCM_UNSUPPORTED, number));
    broadcastComplete(false);
  } catch (AccountVerificationTimeoutException avte) {
    Log.w("RegistrationService", avte);
    setState(new RegistrationState(RegistrationState.STATE_TIMEOUT, number));
    broadcastComplete(false);
  } catch (IOException e) {
    Log.w("RegistrationService", e);
    setState(new RegistrationState(RegistrationState.STATE_NETWORK_ERROR, number));
    broadcastComplete(false);
  } finally {
    shutdownChallengeListener();
  }
}
 

import org.whispersystems.libsignal.util.KeyHelper; //导入依赖的package包/类
private static int generateRegistrationId() {
	Log.i(Config.LOGTAG, AxolotlService.LOGPREFIX + " : " + "Generating axolotl registration ID...");
	return KeyHelper.generateRegistrationId(true);
}
 

import org.whispersystems.libsignal.util.KeyHelper; //导入依赖的package包/类
private IdentityKeyPair generateIdentityKeyPair() {
    final IdentityKeyPair ikp = KeyHelper.generateIdentityKeyPair();
    SignalPreferences.setSerializedIdentityKeyPair(ikp.serialize());
    return ikp;
}
 

import org.whispersystems.libsignal.util.KeyHelper; //导入依赖的package包/类
private int generateLocalRegistrationId() {
    final int rid = KeyHelper.generateRegistrationId(false);
    SignalPreferences.setLocalRegistrationId(rid);
    return rid;
}
 

import org.whispersystems.libsignal.util.KeyHelper; //导入依赖的package包/类
private static int generateRegistrationId() {
    Log.i(Config.LOGTAG, AxolotlService.LOGPREFIX + " : " + "Generating axolotl registration ID...");
    return KeyHelper.generateRegistrationId(true);
}
 

import org.whispersystems.libsignal.util.KeyHelper; //导入依赖的package包/类
private static int generateRegistrationId() {
  return KeyHelper.generateRegistrationId(false);
}