aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorMoxie Marlinspike <moxie@thoughtcrime.org>2014-11-24 12:54:30 -0800
committerMoxie Marlinspike <moxie@thoughtcrime.org>2014-11-24 12:54:30 -0800
commit60800e155612bea797eed93c67046a23d26054cc (patch)
treed88368c1c26162e27e790195133ca2b526597afe
Break out into separate repo.
Diffstat (limited to '')
-rw-r--r--.gitignore3
-rw-r--r--README.md85
-rw-r--r--build.gradle44
-rw-r--r--jni/Android.mk27
-rw-r--r--jni/Application.mk1
-rw-r--r--jni/curve25519-donna.c870
-rw-r--r--jni/curve25519-donna.h6
-rw-r--r--jni/curve25519-jni.c109
-rw-r--r--jni/ed25519/additions/compare.c44
-rw-r--r--jni/ed25519/additions/compare.h6
-rw-r--r--jni/ed25519/additions/crypto_hash_sha512.h6
-rw-r--r--jni/ed25519/additions/curve_sigs.c116
-rw-r--r--jni/ed25519/additions/curve_sigs.h50
-rw-r--r--jni/ed25519/additions/sign_modified.c47
-rw-r--r--jni/ed25519/additions/zeroize.c17
-rw-r--r--jni/ed25519/additions/zeroize.h12
-rw-r--r--jni/ed25519/api.h4
-rw-r--r--jni/ed25519/base.h1344
-rw-r--r--jni/ed25519/base2.h40
-rw-r--r--jni/ed25519/d.h1
-rw-r--r--jni/ed25519/d2.h1
-rw-r--r--jni/ed25519/fe.h56
-rw-r--r--jni/ed25519/fe_0.c19
-rw-r--r--jni/ed25519/fe_1.c19
-rw-r--r--jni/ed25519/fe_add.c57
-rw-r--r--jni/ed25519/fe_cmov.c63
-rw-r--r--jni/ed25519/fe_copy.c29
-rw-r--r--jni/ed25519/fe_frombytes.c73
-rw-r--r--jni/ed25519/fe_invert.c14
-rw-r--r--jni/ed25519/fe_isnegative.c16
-rw-r--r--jni/ed25519/fe_isnonzero.c19
-rw-r--r--jni/ed25519/fe_mul.c253
-rw-r--r--jni/ed25519/fe_neg.c45
-rw-r--r--jni/ed25519/fe_pow22523.c13
-rw-r--r--jni/ed25519/fe_sq.c149
-rw-r--r--jni/ed25519/fe_sq2.c160
-rw-r--r--jni/ed25519/fe_sub.c57
-rw-r--r--jni/ed25519/fe_tobytes.c119
-rw-r--r--jni/ed25519/ge.h95
-rw-r--r--jni/ed25519/ge_add.c11
-rw-r--r--jni/ed25519/ge_add.h97
-rw-r--r--jni/ed25519/ge_double_scalarmult.c96
-rw-r--r--jni/ed25519/ge_frombytes.c50
-rw-r--r--jni/ed25519/ge_madd.c11
-rw-r--r--jni/ed25519/ge_madd.h88
-rw-r--r--jni/ed25519/ge_msub.c11
-rw-r--r--jni/ed25519/ge_msub.h88
-rw-r--r--jni/ed25519/ge_p1p1_to_p2.c12
-rw-r--r--jni/ed25519/ge_p1p1_to_p3.c13
-rw-r--r--jni/ed25519/ge_p2_0.c8
-rw-r--r--jni/ed25519/ge_p2_dbl.c11
-rw-r--r--jni/ed25519/ge_p2_dbl.h73
-rw-r--r--jni/ed25519/ge_p3_0.c9
-rw-r--r--jni/ed25519/ge_p3_dbl.c12
-rw-r--r--jni/ed25519/ge_p3_to_cached.c17
-rw-r--r--jni/ed25519/ge_p3_to_p2.c12
-rw-r--r--jni/ed25519/ge_p3_tobytes.c14
-rw-r--r--jni/ed25519/ge_precomp_0.c8
-rw-r--r--jni/ed25519/ge_scalarmult_base.c105
-rw-r--r--jni/ed25519/ge_sub.c11
-rw-r--r--jni/ed25519/ge_sub.h97
-rw-r--r--jni/ed25519/ge_tobytes.c14
-rw-r--r--jni/ed25519/main/main.c106
-rw-r--r--jni/ed25519/nacl_includes/crypto_int32.h6
-rw-r--r--jni/ed25519/nacl_includes/crypto_int64.h6
-rw-r--r--jni/ed25519/nacl_includes/crypto_sign.h16
-rw-r--r--jni/ed25519/nacl_includes/crypto_sign_edwards25519sha512batch.h33
-rw-r--r--jni/ed25519/nacl_includes/crypto_uint32.h6
-rw-r--r--jni/ed25519/nacl_includes/crypto_uint64.h6
-rw-r--r--jni/ed25519/nacl_includes/crypto_verify_32.h22
-rw-r--r--jni/ed25519/nacl_sha512/blocks.c238
-rw-r--r--jni/ed25519/nacl_sha512/hash.c71
-rw-r--r--jni/ed25519/open.c48
-rw-r--r--jni/ed25519/pow22523.h160
-rw-r--r--jni/ed25519/pow225521.h160
-rw-r--r--jni/ed25519/sc.h15
-rw-r--r--jni/ed25519/sc_muladd.c368
-rw-r--r--jni/ed25519/sc_reduce.c275
-rw-r--r--jni/ed25519/sign.c41
-rw-r--r--jni/ed25519/sqrtm1.h1
-rwxr-xr-xlibs/armeabi-v7a/libcurve25519.sobin0 -> 135228 bytes
-rwxr-xr-xlibs/armeabi/libcurve25519.sobin0 -> 131128 bytes
-rwxr-xr-xlibs/mips/libcurve25519.sobin0 -> 235636 bytes
-rwxr-xr-xlibs/x86/libcurve25519.sobin0 -> 163904 bytes
-rw-r--r--protobuf/LocalStorageProtocol.proto112
-rw-r--r--protobuf/Makefile3
-rw-r--r--protobuf/WhisperTextProtocol.proto41
-rw-r--r--src/androidTest/java/org/whispersystems/test/InMemoryAxolotlStore.java115
-rw-r--r--src/androidTest/java/org/whispersystems/test/InMemoryIdentityKeyStore.java53
-rw-r--r--src/androidTest/java/org/whispersystems/test/InMemoryPreKeyStore.java42
-rw-r--r--src/androidTest/java/org/whispersystems/test/InMemorySessionStore.java68
-rw-r--r--src/androidTest/java/org/whispersystems/test/InMemorySignedPreKeyStore.java59
-rw-r--r--src/androidTest/java/org/whispersystems/test/SessionBuilderTest.java601
-rw-r--r--src/androidTest/java/org/whispersystems/test/SessionCipherTest.java206
-rw-r--r--src/androidTest/java/org/whispersystems/test/SimultaneousInitiateTests.java501
-rw-r--r--src/androidTest/java/org/whispersystems/test/ecc/Curve25519Test.java154
-rw-r--r--src/androidTest/java/org/whispersystems/test/groups/GroupCipherTest.java151
-rw-r--r--src/androidTest/java/org/whispersystems/test/groups/InMemorySenderKeyStore.java33
-rw-r--r--src/androidTest/java/org/whispersystems/test/kdf/HKDFTest.java139
-rw-r--r--src/androidTest/java/org/whispersystems/test/ratchet/ChainKeyTest.java59
-rw-r--r--src/androidTest/java/org/whispersystems/test/ratchet/RatchetingSessionTest.java236
-rw-r--r--src/androidTest/java/org/whispersystems/test/ratchet/RootKeyTest.java84
-rw-r--r--src/main/AndroidManifest.xml7
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/DuplicateMessageException.java7
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/IdentityKey.java66
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/IdentityKeyPair.java66
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/InvalidKeyException.java34
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/InvalidKeyIdException.java27
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/InvalidMacException.java28
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/InvalidMessageException.java40
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/InvalidVersionException.java23
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/LegacyMessageException.java7
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/NoSessionException.java11
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/SessionBuilder.java411
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/SessionCipher.java469
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/StaleKeyExchangeException.java4
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/UntrustedIdentityException.java4
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/ecc/Curve.java78
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/ecc/Curve25519.java98
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/ecc/DjbECPrivateKey.java41
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/ecc/DjbECPublicKey.java66
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/ecc/ECKeyPair.java37
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/ecc/ECPrivateKey.java23
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/ecc/ECPublicKey.java27
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/groups/GroupCipher.java146
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/groups/GroupSessionBuilder.java38
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/groups/ratchet/SenderChainKey.java49
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/groups/ratchet/SenderMessageKey.java38
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/groups/state/SenderKeyRecord.java64
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/groups/state/SenderKeyState.java144
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/groups/state/SenderKeyStore.java6
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/kdf/DerivedMessageSecrets.java61
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/kdf/DerivedRootSecrets.java26
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/kdf/HKDF.java93
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/kdf/HKDFv2.java8
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/kdf/HKDFv3.java8
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/protocol/CiphertextMessage.java35
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/protocol/KeyExchangeMessage.java153
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/protocol/PreKeyWhisperMessage.java147
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/protocol/SenderKeyDistributionMessage.java56
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/protocol/SenderKeyMessage.java121
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/protocol/WhisperMessage.java172
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/protocol/WhisperProtos.java3532
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/ratchet/AliceAxolotlParameters.java109
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/ratchet/BobAxolotlParameters.java109
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/ratchet/ChainKey.java75
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/ratchet/MessageKeys.java51
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/ratchet/RatchetingSession.java179
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/ratchet/RootKey.java54
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/ratchet/SymmetricAxolotlParameters.java108
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/state/AxolotlStore.java6
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/state/IdentityKeyStore.java57
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/state/PreKeyBundle.java96
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/state/PreKeyRecord.java51
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/state/PreKeyStore.java42
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/state/SessionRecord.java117
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/state/SessionState.java509
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/state/SessionStore.java68
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/state/SignedPreKeyRecord.java61
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/state/SignedPreKeyStore.java47
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/state/StorageProtos.java11779
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/util/ByteUtil.java248
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/util/Hex.java77
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/util/KeyHelper.java143
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/util/Medium.java5
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/util/Pair.java51
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/util/guava/Absent.java87
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/util/guava/Function.java61
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/util/guava/Optional.java232
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/util/guava/Preconditions.java447
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/util/guava/Present.java88
-rw-r--r--src/main/java/org/whispersystems/libaxolotl/util/guava/Supplier.java36
172 files changed, 30656 insertions, 0 deletions
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..8c22aafa
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,3 @@
+/build
+/obj
+*.iml
diff --git a/README.md b/README.md
new file mode 100644
index 00000000..9a3828c0
--- /dev/null
+++ b/README.md
@@ -0,0 +1,85 @@
+
+# Overview
+
+This is a ratcheting forward secrecy protocol that works in synchronous and asynchronous messaging
+environments. The protocol overview is available [here](https://github.com/trevp/axolotl/wiki),
+and the details of the wire format are available [here](https://github.com/WhisperSystems/TextSecure/wiki/ProtocolV2).
+
+## PreKeys
+
+This protocol uses a concept called 'PreKeys'. A PreKey is an ECPublicKey and an associated unique
+ID which are stored together by a server. PreKeys can also be signed.
+
+At install time, clients generate a single signed PreKey, as well as a large list of unsigned
+PreKeys, and transmit all of them to the server.
+
+## Sessions
+
+The axolotl protocol is session-oriented. Clients establish a "session," which is then used for
+all subsequent encrypt/decrypt operations. There is no need to ever tear down a session once one
+has been established.
+
+Sessions are established in one of three ways:
+
+1. PreKeyBundles. A client that wishes to send a message to a recipient can establish a session by
+ retrieving a PreKeyBundle for that recipient from the server.
+1. PreKeyWhisperMessages. A client can receive a PreKeyWhisperMessage from a recipient and use it
+ to establish a session.
+1. KeyExchangeMessages. Two clients can exchange KeyExchange messages to establish a session.
+
+## State
+
+An established session encapsulates a lot of state between two clients. That state is maintained
+in durable records which need to be kept for the life of the session.
+
+State is kept in the following places:
+
+1. Identity State. Clients will need to maintain the state of their own identity key pair, as well
+ as identity keys received from other clients.
+1. PreKey State. Clients will need to maintain the state of their generated PreKeys.
+1. Signed PreKey States. Clients will need to maintain the state of their signed PreKeys.
+1. Session State. Clients will need to maintain the state of the sessions they have established.
+
+# Using libaxolotl
+
+## Install time
+
+At install time, a libaxolotl client needs to generate its identity keys, registration id, and
+prekeys.
+
+ IdentityKeyPair identityKeyPair = KeyHelper.generateIdentityKeyPair();
+ int registrationId = KeyHelper.generateRegistrationId();
+ List<PreKeyRecord> preKeys = KeyHelper.generatePreKeys(startId, 100);
+ PreKeyRecord lastResortKey = KeyHelper.generateLastResortKey();
+ SignedPreKeyRecord signedPreKey = KeyHelper.generateSignedPreKey(identityKeyPair, 5);
+
+ // Store identityKeyPair somewhere durable and safe.
+ // Store registrationId somewhere durable and safe.
+
+ // Store preKeys in PreKeyStore.
+ // Store signed prekey in SignedPreKeyStore.
+
+## Building a session
+
+A libaxolotl client needs to implement four interfaces: IdentityKeyStore, PreKeyStore,
+SignedPreKeyStore, and SessionStore. These will manage loading and storing of identity,
+prekeys, signed prekeys, and session state.
+
+Once those are implemented, building a session is fairly straightforward:
+
+ SessionStore sessionStore = new MySessionStore();
+ PreKeyStore preKeyStore = new MyPreKeyStore();
+ SignedPreKeyStore signedPreKeyStore = new MySignedPreKeyStore();
+ IdentityKeyStore identityStore = new MyIdentityKeyStore();
+
+ // Instantiate a SessionBuilder for a remote recipientId + deviceId tuple.
+ SessionBuilder sessionBuilder = new SessionBuilder(sessionStore, preKeyStore, signedPreKeyStore,
+ identityStore, recipientId, deviceId);
+
+ // Build a session with a PreKey retrieved from the server.
+ sessionBuilder.process(retrievedPreKey);
+
+ SessionCipher sessionCipher = new SessionCipher(sessionStore, recipientId, deviceId);
+ CiphertextMessage message = sessionCipher.encrypt("Hello world!".getBytes("UTF-8"));
+
+ deliver(message.serialize());
diff --git a/build.gradle b/build.gradle
new file mode 100644
index 00000000..2b623a3f
--- /dev/null
+++ b/build.gradle
@@ -0,0 +1,44 @@
+buildscript {
+ repositories {
+ mavenCentral()
+ }
+
+ dependencies {
+ classpath 'com.android.tools.build:gradle:0.14.2'
+ }
+}
+
+apply plugin: 'com.android.library'
+
+repositories {
+ mavenCentral()
+}
+
+dependencies {
+ compile 'com.google.protobuf:protobuf-java:2.5.0'
+}
+
+android {
+ compileSdkVersion 21
+ buildToolsVersion '21.1.1'
+
+ compileOptions {
+ sourceCompatibility JavaVersion.VERSION_1_7
+ targetCompatibility JavaVersion.VERSION_1_7
+ }
+
+ android {
+ sourceSets {
+ main {
+ jniLibs.srcDirs = ['libs']
+ }
+ }
+ }
+
+}
+
+tasks.whenTaskAdded { task ->
+ if (task.name.equals("lint")) {
+ task.enabled = false
+ }
+} \ No newline at end of file
diff --git a/jni/Android.mk b/jni/Android.mk
new file mode 100644
index 00000000..fea39cf3
--- /dev/null
+++ b/jni/Android.mk
@@ -0,0 +1,27 @@
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libcurve25519-donna
+LOCAL_SRC_FILES := curve25519-donna.c
+
+include $(BUILD_STATIC_LIBRARY)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libcurve25519-ref10
+LOCAL_SRC_FILES := $(wildcard ed25519/*.c) $(wildcard ed25519/additions/*.c) $(wildcard ed25519/nacl_sha512/*.c)
+LOCAL_C_INCLUDES := ed25519/nacl_includes ed25519/additions ed25519/sha512 ed25519
+
+include $(BUILD_STATIC_LIBRARY)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libcurve25519
+LOCAL_SRC_FILES := curve25519-jni.c
+LOCAL_C_INCLUDES := ed25519/additions
+
+LOCAL_STATIC_LIBRARIES := libcurve25519-donna libcurve25519-ref10
+
+include $(BUILD_SHARED_LIBRARY)
+
diff --git a/jni/Application.mk b/jni/Application.mk
new file mode 100644
index 00000000..e942d8e6
--- /dev/null
+++ b/jni/Application.mk
@@ -0,0 +1 @@
+APP_ABI := armeabi armeabi-v7a x86 mips
diff --git a/jni/curve25519-donna.c b/jni/curve25519-donna.c
new file mode 100644
index 00000000..f2c2ac58
--- /dev/null
+++ b/jni/curve25519-donna.c
@@ -0,0 +1,870 @@
+/* Copyright 2008, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * curve25519-donna: Curve25519 elliptic curve, public key function
+ *
+ * http://code.google.com/p/curve25519-donna/
+ *
+ * Adam Langley <agl@imperialviolet.org>
+ *
+ * Derived from public domain C code by Daniel J. Bernstein <djb@cr.yp.to>
+ *
+ * More information about curve25519 can be found here
+ * http://cr.yp.to/ecdh.html
+ *
+ * djb's sample implementation of curve25519 is written in a special assembly
+ * language called qhasm and uses the floating point registers.
+ *
+ * This is, almost, a clean room reimplementation from the curve25519 paper. It
+ * uses many of the tricks described therein. Only the crecip function is taken
+ * from the sample implementation. */
+
+#include <string.h>
+#include <stdint.h>
+
+#ifdef _MSC_VER
+#define inline __inline
+#endif
+
+typedef uint8_t u8;
+typedef int32_t s32;
+typedef int64_t limb;
+
+/* Field element representation:
+ *
+ * Field elements are written as an array of signed, 64-bit limbs, least
+ * significant first. The value of the field element is:
+ * x[0] + 2^26·x[1] + x^51·x[2] + 2^102·x[3] + ...
+ *
+ * i.e. the limbs are 26, 25, 26, 25, ... bits wide. */
+
+/* Sum two numbers: output += in */
+static void fsum(limb *output, const limb *in) {
+ unsigned i;
+ for (i = 0; i < 10; i += 2) {
+ output[0+i] = output[0+i] + in[0+i];
+ output[1+i] = output[1+i] + in[1+i];
+ }
+}
+
+/* Find the difference of two numbers: output = in - output
+ * (note the order of the arguments!). */
+static void fdifference(limb *output, const limb *in) {
+ unsigned i;
+ for (i = 0; i < 10; ++i) {
+ output[i] = in[i] - output[i];
+ }
+}
+
+/* Multiply a number by a scalar: output = in * scalar */
+static void fscalar_product(limb *output, const limb *in, const limb scalar) {
+ unsigned i;
+ for (i = 0; i < 10; ++i) {
+ output[i] = in[i] * scalar;
+ }
+}
+
+/* Multiply two numbers: output = in2 * in
+ *
+ * output must be distinct to both inputs. The inputs are reduced coefficient
+ * form, the output is not.
+ *
+ * output[x] <= 14 * the largest product of the input limbs. */
+static void fproduct(limb *output, const limb *in2, const limb *in) {
+ output[0] = ((limb) ((s32) in2[0])) * ((s32) in[0]);
+ output[1] = ((limb) ((s32) in2[0])) * ((s32) in[1]) +
+ ((limb) ((s32) in2[1])) * ((s32) in[0]);
+ output[2] = 2 * ((limb) ((s32) in2[1])) * ((s32) in[1]) +
+ ((limb) ((s32) in2[0])) * ((s32) in[2]) +
+ ((limb) ((s32) in2[2])) * ((s32) in[0]);
+ output[3] = ((limb) ((s32) in2[1])) * ((s32) in[2]) +
+ ((limb) ((s32) in2[2])) * ((s32) in[1]) +
+ ((limb) ((s32) in2[0])) * ((s32) in[3]) +
+ ((limb) ((s32) in2[3])) * ((s32) in[0]);
+ output[4] = ((limb) ((s32) in2[2])) * ((s32) in[2]) +
+ 2 * (((limb) ((s32) in2[1])) * ((s32) in[3]) +
+ ((limb) ((s32) in2[3])) * ((s32) in[1])) +
+ ((limb) ((s32) in2[0])) * ((s32) in[4]) +
+ ((limb) ((s32) in2[4])) * ((s32) in[0]);
+ output[5] = ((limb) ((s32) in2[2])) * ((s32) in[3]) +
+ ((limb) ((s32) in2[3])) * ((s32) in[2]) +
+ ((limb) ((s32) in2[1])) * ((s32) in[4]) +
+ ((limb) ((s32) in2[4])) * ((s32) in[1]) +
+ ((limb) ((s32) in2[0])) * ((s32) in[5]) +
+ ((limb) ((s32) in2[5])) * ((s32) in[0]);
+ output[6] = 2 * (((limb) ((s32) in2[3])) * ((s32) in[3]) +
+ ((limb) ((s32) in2[1])) * ((s32) in[5]) +
+ ((limb) ((s32) in2[5])) * ((s32) in[1])) +
+ ((limb) ((s32) in2[2])) * ((s32) in[4]) +
+ ((limb) ((s32) in2[4])) * ((s32) in[2]) +
+ ((limb) ((s32) in2[0])) * ((s32) in[6]) +
+ ((limb) ((s32) in2[6])) * ((s32) in[0]);
+ output[7] = ((limb) ((s32) in2[3])) * ((s32) in[4]) +
+ ((limb) ((s32) in2[4])) * ((s32) in[3]) +
+ ((limb) ((s32) in2[2])) * ((s32) in[5]) +
+ ((limb) ((s32) in2[5])) * ((s32) in[2]) +
+ ((limb) ((s32) in2[1])) * ((s32) in[6]) +
+ ((limb) ((s32) in2[6])) * ((s32) in[1]) +
+ ((limb) ((s32) in2[0])) * ((s32) in[7]) +
+ ((limb) ((s32) in2[7])) * ((s32) in[0]);
+ output[8] = ((limb) ((s32) in2[4])) * ((s32) in[4]) +
+ 2 * (((limb) ((s32) in2[3])) * ((s32) in[5]) +
+ ((limb) ((s32) in2[5])) * ((s32) in[3]) +
+ ((limb) ((s32) in2[1])) * ((s32) in[7]) +
+ ((limb) ((s32) in2[7])) * ((s32) in[1])) +
+ ((limb) ((s32) in2[2])) * ((s32) in[6]) +
+ ((limb) ((s32) in2[6])) * ((s32) in[2]) +
+ ((limb) ((s32) in2[0])) * ((s32) in[8]) +
+ ((limb) ((s32) in2[8])) * ((s32) in[0]);
+ output[9] = ((limb) ((s32) in2[4])) * ((s32) in[5]) +
+ ((limb) ((s32) in2[5])) * ((s32) in[4]) +
+ ((limb) ((s32) in2[3])) * ((s32) in[6]) +
+ ((limb) ((s32) in2[6])) * ((s32) in[3]) +
+ ((limb) ((s32) in2[2])) * ((s32) in[7]) +
+ ((limb) ((s32) in2[7])) * ((s32) in[2]) +
+ ((limb) ((s32) in2[1])) * ((s32) in[8]) +
+ ((limb) ((s32) in2[8])) * ((s32) in[1]) +
+ ((limb) ((s32) in2[0])) * ((s32) in[9]) +
+ ((limb) ((s32) in2[9])) * ((s32) in[0]);
+ output[10] = 2 * (((limb) ((s32) in2[5])) * ((s32) in[5]) +
+ ((limb) ((s32) in2[3])) * ((s32) in[7]) +
+ ((limb) ((s32) in2[7])) * ((s32) in[3]) +
+ ((limb) ((s32) in2[1])) * ((s32) in[9]) +
+ ((limb) ((s32) in2[9])) * ((s32) in[1])) +
+ ((limb) ((s32) in2[4])) * ((s32) in[6]) +
+ ((limb) ((s32) in2[6])) * ((s32) in[4]) +
+ ((limb) ((s32) in2[2])) * ((s32) in[8]) +
+ ((limb) ((s32) in2[8])) * ((s32) in[2]);
+ output[11] = ((limb) ((s32) in2[5])) * ((s32) in[6]) +
+ ((limb) ((s32) in2[6])) * ((s32) in[5]) +
+ ((limb) ((s32) in2[4])) * ((s32) in[7]) +
+ ((limb) ((s32) in2[7])) * ((s32) in[4]) +
+ ((limb) ((s32) in2[3])) * ((s32) in[8]) +
+ ((limb) ((s32) in2[8])) * ((s32) in[3]) +
+ ((limb) ((s32) in2[2])) * ((s32) in[9]) +
+ ((limb) ((s32) in2[9])) * ((s32) in[2]);
+ output[12] = ((limb) ((s32) in2[6])) * ((s32) in[6]) +
+ 2 * (((limb) ((s32) in2[5])) * ((s32) in[7]) +
+ ((limb) ((s32) in2[7])) * ((s32) in[5]) +
+ ((limb) ((s32) in2[3])) * ((s32) in[9]) +
+ ((limb) ((s32) in2[9])) * ((s32) in[3])) +
+ ((limb) ((s32) in2[4])) * ((s32) in[8]) +
+ ((limb) ((s32) in2[8])) * ((s32) in[4]);
+ output[13] = ((limb) ((s32) in2[6])) * ((s32) in[7]) +
+ ((limb) ((s32) in2[7])) * ((s32) in[6]) +
+ ((limb) ((s32) in2[5])) * ((s32) in[8]) +
+ ((limb) ((s32) in2[8])) * ((s32) in[5]) +
+ ((limb) ((s32) in2[4])) * ((s32) in[9]) +
+ ((limb) ((s32) in2[9])) * ((s32) in[4]);
+ output[14] = 2 * (((limb) ((s32) in2[7])) * ((s32) in[7]) +
+ ((limb) ((s32) in2[5])) * ((s32) in[9]) +
+ ((limb) ((s32) in2[9])) * ((s32) in[5])) +
+ ((limb) ((s32) in2[6])) * ((s32) in[8]) +
+ ((limb) ((s32) in2[8])) * ((s32) in[6]);
+ output[15] = ((limb) ((s32) in2[7])) * ((s32) in[8]) +
+ ((limb) ((s32) in2[8])) * ((s32) in[7]) +
+ ((limb) ((s32) in2[6])) * ((s32) in[9]) +
+ ((limb) ((s32) in2[9])) * ((s32) in[6]);
+ output[16] = ((limb) ((s32) in2[8])) * ((s32) in[8]) +
+ 2 * (((limb) ((s32) in2[7])) * ((s32) in[9]) +
+ ((limb) ((s32) in2[9])) * ((s32) in[7]));
+ output[17] = ((limb) ((s32) in2[8])) * ((s32) in[9]) +
+ ((limb) ((s32) in2[9])) * ((s32) in[8]);
+ output[18] = 2 * ((limb) ((s32) in2[9])) * ((s32) in[9]);
+}
+
+/* Reduce a long form to a short form by taking the input mod 2^255 - 19.
+ *
+ * On entry: |output[i]| < 14*2^54
+ * On exit: |output[0..8]| < 280*2^54 */
+static void freduce_degree(limb *output) {
+ /* Each of these shifts and adds ends up multiplying the value by 19.
+ *
+ * For output[0..8], the absolute entry value is < 14*2^54 and we add, at
+ * most, 19*14*2^54 thus, on exit, |output[0..8]| < 280*2^54. */
+ output[8] += output[18] << 4;
+ output[8] += output[18] << 1;
+ output[8] += output[18];
+ output[7] += output[17] << 4;
+ output[7] += output[17] << 1;
+ output[7] += output[17];
+ output[6] += output[16] << 4;
+ output[6] += output[16] << 1;
+ output[6] += output[16];
+ output[5] += output[15] << 4;
+ output[5] += output[15] << 1;
+ output[5] += output[15];
+ output[4] += output[14] << 4;
+ output[4] += output[14] << 1;
+ output[4] += output[14];
+ output[3] += output[13] << 4;
+ output[3] += output[13] << 1;
+ output[3] += output[13];
+ output[2] += output[12] << 4;
+ output[2] += output[12] << 1;
+ output[2] += output[12];
+ output[1] += output[11] << 4;
+ output[1] += output[11] << 1;
+ output[1] += output[11];
+ output[0] += output[10] << 4;
+ output[0] += output[10] << 1;
+ output[0] += output[10];
+}
+
+#if (-1 & 3) != 3
+#error "This code only works on a two's complement system"
+#endif
+
+/* return v / 2^26, using only shifts and adds.
+ *
+ * On entry: v can take any value. */
+static inline limb
+div_by_2_26(const limb v)
+{
+ /* High word of v; no shift needed. */
+ const uint32_t highword = (uint32_t) (((uint64_t) v) >> 32);
+ /* Set to all 1s if v was negative; else set to 0s. */
+ const int32_t sign = ((int32_t) highword) >> 31;
+ /* Set to 0x3ffffff if v was negative; else set to 0. */
+ const int32_t roundoff = ((uint32_t) sign) >> 6;
+ /* Should return v / (1<<26) */
+ return (v + roundoff) >> 26;
+}
+
+/* return v / (2^25), using only shifts and adds.
+ *
+ * On entry: v can take any value. */
+static inline limb
+div_by_2_25(const limb v)
+{
+ /* High word of v; no shift needed*/
+ const uint32_t highword = (uint32_t) (((uint64_t) v) >> 32);
+ /* Set to all 1s if v was negative; else set to 0s. */
+ const int32_t sign = ((int32_t) highword) >> 31;
+ /* Set to 0x1ffffff if v was negative; else set to 0. */
+ const int32_t roundoff = ((uint32_t) sign) >> 7;
+ /* Should return v / (1<<25) */
+ return (v + roundoff) >> 25;
+}
+
+/* return v / (2^25), using only shifts and adds.
+ *
+ * On entry: v can take any value. */
+static inline s32
+div_s32_by_2_25(const s32 v)
+{
+ const s32 roundoff = ((uint32_t)(v >> 31)) >> 7;
+ return (v + roundoff) >> 25;
+}
+
+/* Reduce all coefficients of the short form input so that |x| < 2^26.
+ *
+ * On entry: |output[i]| < 280*2^54 */
+static void freduce_coefficients(limb *output) {
+ unsigned i;
+
+ output[10] = 0;
+
+ for (i = 0; i < 10; i += 2) {
+ limb over = div_by_2_26(output[i]);
+ /* The entry condition (that |output[i]| < 280*2^54) means that over is, at
+ * most, 280*2^28 in the first iteration of this loop. This is added to the
+ * next limb and we can approximate the resulting bound of that limb by
+ * 281*2^54. */
+ output[i] -= over << 26;
+ output[i+1] += over;
+
+ /* For the first iteration, |output[i+1]| < 281*2^54, thus |over| <
+ * 281*2^29. When this is added to the next limb, the resulting bound can
+ * be approximated as 281*2^54.
+ *
+ * For subsequent iterations of the loop, 281*2^54 remains a conservative
+ * bound and no overflow occurs. */
+ over = div_by_2_25(output[i+1]);
+ output[i+1] -= over << 25;
+ output[i+2] += over;
+ }
+ /* Now |output[10]| < 281*2^29 and all other coefficients are reduced. */
+ output[0] += output[10] << 4;
+ output[0] += output[10] << 1;
+ output[0] += output[10];
+
+ output[10] = 0;
+
+ /* Now output[1..9] are reduced, and |output[0]| < 2^26 + 19*281*2^29
+ * So |over| will be no more than 2^16. */
+ {
+ limb over = div_by_2_26(output[0]);
+ output[0] -= over << 26;
+ output[1] += over;
+ }
+
+ /* Now output[0,2..9] are reduced, and |output[1]| < 2^25 + 2^16 < 2^26. The
+ * bound on |output[1]| is sufficient to meet our needs. */
+}
+
+/* A helpful wrapper around fproduct: output = in * in2.
+ *
+ * On entry: |in[i]| < 2^27 and |in2[i]| < 2^27.
+ *
+ * output must be distinct to both inputs. The output is reduced degree
+ * (indeed, one need only provide storage for 10 limbs) and |output[i]| < 2^26. */
+static void
+fmul(limb *output, const limb *in, const limb *in2) {
+ limb t[19];
+ fproduct(t, in, in2);
+ /* |t[i]| < 14*2^54 */
+ freduce_degree(t);
+ freduce_coefficients(t);
+ /* |t[i]| < 2^26 */
+ memcpy(output, t, sizeof(limb) * 10);
+}
+
+/* Square a number: output = in**2
+ *
+ * output must be distinct from the input. The inputs are reduced coefficient
+ * form, the output is not.
+ *
+ * output[x] <= 14 * the largest product of the input limbs. */
+static void fsquare_inner(limb *output, const limb *in) {
+ output[0] = ((limb) ((s32) in[0])) * ((s32) in[0]);
+ output[1] = 2 * ((limb) ((s32) in[0])) * ((s32) in[1]);
+ output[2] = 2 * (((limb) ((s32) in[1])) * ((s32) in[1]) +
+ ((limb) ((s32) in[0])) * ((s32) in[2]));
+ output[3] = 2 * (((limb) ((s32) in[1])) * ((s32) in[2]) +
+ ((limb) ((s32) in[0])) * ((s32) in[3]));
+ output[4] = ((limb) ((s32) in[2])) * ((s32) in[2]) +
+ 4 * ((limb) ((s32) in[1])) * ((s32) in[3]) +
+ 2 * ((limb) ((s32) in[0])) * ((s32) in[4]);
+ output[5] = 2 * (((limb) ((s32) in[2])) * ((s32) in[3]) +
+ ((limb) ((s32) in[1])) * ((s32) in[4]) +
+ ((limb) ((s32) in[0])) * ((s32) in[5]));
+ output[6] = 2 * (((limb) ((s32) in[3])) * ((s32) in[3]) +
+ ((limb) ((s32) in[2])) * ((s32) in[4]) +
+ ((limb) ((s32) in[0])) * ((s32) in[6]) +
+ 2 * ((limb) ((s32) in[1])) * ((s32) in[5]));
+ output[7] = 2 * (((limb) ((s32) in[3])) * ((s32) in[4]) +
+ ((limb) ((s32) in[2])) * ((s32) in[5]) +
+ ((limb) ((s32) in[1])) * ((s32) in[6]) +
+ ((limb) ((s32) in[0])) * ((s32) in[7]));
+ output[8] = ((limb) ((s32) in[4])) * ((s32) in[4]) +
+ 2 * (((limb) ((s32) in[2])) * ((s32) in[6]) +
+ ((limb) ((s32) in[0])) * ((s32) in[8]) +
+ 2 * (((limb) ((s32) in[1])) * ((s32) in[7]) +
+ ((limb) ((s32) in[3])) * ((s32) in[5])));
+ output[9] = 2 * (((limb) ((s32) in[4])) * ((s32) in[5]) +
+ ((limb) ((s32) in[3])) * ((s32) in[6]) +
+ ((limb) ((s32) in[2])) * ((s32) in[7]) +
+ ((limb) ((s32) in[1])) * ((s32) in[8]) +
+ ((limb) ((s32) in[0])) * ((s32) in[9]));
+ output[10] = 2 * (((limb) ((s32) in[5])) * ((s32) in[5]) +
+ ((limb) ((s32) in[4])) * ((s32) in[6]) +
+ ((limb) ((s32) in[2])) * ((s32) in[8]) +
+ 2 * (((limb) ((s32) in[3])) * ((s32) in[7]) +
+ ((limb) ((s32) in[1])) * ((s32) in[9])));
+ output[11] = 2 * (((limb) ((s32) in[5])) * ((s32) in[6]) +
+ ((limb) ((s32) in[4])) * ((s32) in[7]) +
+ ((limb) ((s32) in[3])) * ((s32) in[8]) +
+ ((limb) ((s32) in[2])) * ((s32) in[9]));
+ output[12] = ((limb) ((s32) in[6])) * ((s32) in[6]) +
+ 2 * (((limb) ((s32) in[4])) * ((s32) in[8]) +
+ 2 * (((limb) ((s32) in[5])) * ((s32) in[7]) +
+ ((limb) ((s32) in[3])) * ((s32) in[9])));
+ output[13] = 2 * (((limb) ((s32) in[6])) * ((s32) in[7]) +
+ ((limb) ((s32) in[5])) * ((s32) in[8]) +
+ ((limb) ((s32) in[4])) * ((s32) in[9]));
+ output[14] = 2 * (((limb) ((s32) in[7])) * ((s32) in[7]) +
+ ((limb) ((s32) in[6])) * ((s32) in[8]) +
+ 2 * ((limb) ((s32) in[5])) * ((s32) in[9]));
+ output[15] = 2 * (((limb) ((s32) in[7])) * ((s32) in[8]) +
+ ((limb) ((s32) in[6])) * ((s32) in[9]));
+ output[16] = ((limb) ((s32) in[8])) * ((s32) in[8]) +
+ 4 * ((limb) ((s32) in[7])) * ((s32) in[9]);
+ output[17] = 2 * ((limb) ((s32) in[8])) * ((s32) in[9]);
+ output[18] = 2 * ((limb) ((s32) in[9])) * ((s32) in[9]);
+}
+
+/* fsquare sets output = in^2.
+ *
+ * On entry: The |in| argument is in reduced coefficients form and |in[i]| <
+ * 2^27.
+ *
+ * On exit: The |output| argument is in reduced coefficients form (indeed, one
+ * need only provide storage for 10 limbs) and |out[i]| < 2^26. */
+static void
+fsquare(limb *output, const limb *in) {
+ limb t[19];
+ fsquare_inner(t, in);
+ /* |t[i]| < 14*2^54 because the largest product of two limbs will be <
+ * 2^(27+27) and fsquare_inner adds together, at most, 14 of those
+ * products. */
+ freduce_degree(t);
+ freduce_coefficients(t);
+ /* |t[i]| < 2^26 */
+ memcpy(output, t, sizeof(limb) * 10);
+}
+
+/* Take a little-endian, 32-byte number and expand it into polynomial form */
+static void
+fexpand(limb *output, const u8 *input) {
+#define F(n,start,shift,mask) \
+ output[n] = ((((limb) input[start + 0]) | \
+ ((limb) input[start + 1]) << 8 | \
+ ((limb) input[start + 2]) << 16 | \
+ ((limb) input[start + 3]) << 24) >> shift) & mask;
+ F(0, 0, 0, 0x3ffffff);
+ F(1, 3, 2, 0x1ffffff);
+ F(2, 6, 3, 0x3ffffff);
+ F(3, 9, 5, 0x1ffffff);
+ F(4, 12, 6, 0x3ffffff);
+ F(5, 16, 0, 0x1ffffff);
+ F(6, 19, 1, 0x3ffffff);
+ F(7, 22, 3, 0x1ffffff);
+ F(8, 25, 4, 0x3ffffff);
+ F(9, 28, 6, 0x1ffffff);
+#undef F
+}
+
+#if (-32 >> 1) != -16
+#error "This code only works when >> does sign-extension on negative numbers"
+#endif
+
+/* s32_eq returns 0xffffffff iff a == b and zero otherwise. */
+static s32 s32_eq(s32 a, s32 b) {
+ a = ~(a ^ b);
+ a &= a << 16;
+ a &= a << 8;
+ a &= a << 4;
+ a &= a << 2;
+ a &= a << 1;
+ return a >> 31;
+}
+
+/* s32_gte returns 0xffffffff if a >= b and zero otherwise, where a and b are
+ * both non-negative. */
+static s32 s32_gte(s32 a, s32 b) {
+ a -= b;
+ /* a >= 0 iff a >= b. */
+ return ~(a >> 31);
+}
+
+/* Take a fully reduced polynomial form number and contract it into a
+ * little-endian, 32-byte array.
+ *
+ * On entry: |input_limbs[i]| < 2^26 */
+static void
+fcontract(u8 *output, limb *input_limbs) {
+ int i;
+ int j;
+ s32 input[10];
+ s32 mask;
+
+ /* |input_limbs[i]| < 2^26, so it's valid to convert to an s32. */
+ for (i = 0; i < 10; i++) {
+ input[i] = input_limbs[i];
+ }
+
+ for (j = 0; j < 2; ++j) {
+ for (i = 0; i < 9; ++i) {
+ if ((i & 1) == 1) {
+ /* This calculation is a time-invariant way to make input[i]
+ * non-negative by borrowing from the next-larger limb. */
+ const s32 mask = input[i] >> 31;
+ const s32 carry = -((input[i] & mask) >> 25);
+ input[i] = input[i] + (carry << 25);
+ input[i+1] = input[i+1] - carry;
+ } else {
+ const s32 mask = input[i] >> 31;
+ const s32 carry = -((input[i] & mask) >> 26);
+ input[i] = input[i] + (carry << 26);
+ input[i+1] = input[i+1] - carry;
+ }
+ }
+
+ /* There's no greater limb for input[9] to borrow from, but we can multiply
+ * by 19 and borrow from input[0], which is valid mod 2^255-19. */
+ {
+ const s32 mask = input[9] >> 31;
+ const s32 carry = -((input[9] & mask) >> 25);
+ input[9] = input[9] + (carry << 25);
+ input[0] = input[0] - (carry * 19);
+ }
+
+ /* After the first iteration, input[1..9] are non-negative and fit within
+ * 25 or 26 bits, depending on position. However, input[0] may be
+ * negative. */
+ }
+
+ /* The first borrow-propagation pass above ended with every limb
+ except (possibly) input[0] non-negative.
+
+ If input[0] was negative after the first pass, then it was because of a
+ carry from input[9]. On entry, input[9] < 2^26 so the carry was, at most,
+ one, since (2**26-1) >> 25 = 1. Thus input[0] >= -19.
+
+ In the second pass, each limb is decreased by at most one. Thus the second
+ borrow-propagation pass could only have wrapped around to decrease
+ input[0] again if the first pass left input[0] negative *and* input[1]
+ through input[9] were all zero. In that case, input[1] is now 2^25 - 1,
+ and this last borrow-propagation step will leave input[1] non-negative. */
+ {
+ const s32 mask = input[0] >> 31;
+ const s32 carry = -((input[0] & mask) >> 26);
+ input[0] = input[0] + (carry << 26);
+ input[1] = input[1] - carry;
+ }
+
+ /* All input[i] are now non-negative. However, there might be values between
+ * 2^25 and 2^26 in a limb which is, nominally, 25 bits wide. */
+ for (j = 0; j < 2; j++) {
+ for (i = 0; i < 9; i++) {
+ if ((i & 1) == 1) {
+ const s32 carry = input[i] >> 25;
+ input[i] &= 0x1ffffff;
+ input[i+1] += carry;
+ } else {
+ const s32 carry = input[i] >> 26;
+ input[i] &= 0x3ffffff;
+ input[i+1] += carry;
+ }
+ }
+
+ {
+ const s32 carry = input[9] >> 25;
+ input[9] &= 0x1ffffff;
+ input[0] += 19*carry;
+ }
+ }
+
+ /* If the first carry-chain pass, just above, ended up with a carry from
+ * input[9], and that caused input[0] to be out-of-bounds, then input[0] was
+ * < 2^26 + 2*19, because the carry was, at most, two.
+ *
+ * If the second pass carried from input[9] again then input[0] is < 2*19 and
+ * the input[9] -> input[0] carry didn't push input[0] out of bounds. */
+
+ /* It still remains the case that input might be between 2^255-19 and 2^255.
+ * In this case, input[1..9] must take their maximum value and input[0] must
+ * be >= (2^255-19) & 0x3ffffff, which is 0x3ffffed. */
+ mask = s32_gte(input[0], 0x3ffffed);
+ for (i = 1; i < 10; i++) {
+ if ((i & 1) == 1) {
+ mask &= s32_eq(input[i], 0x1ffffff);
+ } else {
+ mask &= s32_eq(input[i], 0x3ffffff);
+ }
+ }
+
+ /* mask is either 0xffffffff (if input >= 2^255-19) and zero otherwise. Thus
+ * this conditionally subtracts 2^255-19. */
+ input[0] -= mask & 0x3ffffed;
+
+ for (i = 1; i < 10; i++) {
+ if ((i & 1) == 1) {
+ input[i] -= mask & 0x1ffffff;
+ } else {
+ input[i] -= mask & 0x3ffffff;
+ }
+ }
+
+ input[1] <<= 2;
+ input[2] <<= 3;
+ input[3] <<= 5;
+ input[4] <<= 6;
+ input[6] <<= 1;
+ input[7] <<= 3;
+ input[8] <<= 4;
+ input[9] <<= 6;
+#define F(i, s) \
+ output[s+0] |= input[i] & 0xff; \
+ output[s+1] = (input[i] >> 8) & 0xff; \
+ output[s+2] = (input[i] >> 16) & 0xff; \
+ output[s+3] = (input[i] >> 24) & 0xff;
+ output[0] = 0;
+ output[16] = 0;
+ F(0,0);
+ F(1,3);
+ F(2,6);
+ F(3,9);
+ F(4,12);
+ F(5,16);
+ F(6,19);
+ F(7,22);
+ F(8,25);
+ F(9,28);
+#undef F
+}
+
+/* Input: Q, Q', Q-Q'
+ * Output: 2Q, Q+Q'
+ *
+ * x2 z3: long form
+ * x3 z3: long form
+ * x z: short form, destroyed
+ * xprime zprime: short form, destroyed
+ * qmqp: short form, preserved
+ *
+ * On entry and exit, the absolute value of the limbs of all inputs and outputs
+ * are < 2^26. */
+static void fmonty(limb *x2, limb *z2, /* output 2Q */
+ limb *x3, limb *z3, /* output Q + Q' */
+ limb *x, limb *z, /* input Q */
+ limb *xprime, limb *zprime, /* input Q' */
+ const limb *qmqp /* input Q - Q' */) {
+ limb origx[10], origxprime[10], zzz[19], xx[19], zz[19], xxprime[19],
+ zzprime[19], zzzprime[19], xxxprime[19];
+
+ memcpy(origx, x, 10 * sizeof(limb));
+ fsum(x, z);
+ /* |x[i]| < 2^27 */
+ fdifference(z, origx); /* does x - z */
+ /* |z[i]| < 2^27 */
+
+ memcpy(origxprime, xprime, sizeof(limb) * 10);
+ fsum(xprime, zprime);
+ /* |xprime[i]| < 2^27 */
+ fdifference(zprime, origxprime);
+ /* |zprime[i]| < 2^27 */
+ fproduct(xxprime, xprime, z);
+ /* |xxprime[i]| < 14*2^54: the largest product of two limbs will be <
+ * 2^(27+27) and fproduct adds together, at most, 14 of those products.
+ * (Approximating that to 2^58 doesn't work out.) */
+ fproduct(zzprime, x, zprime);
+ /* |zzprime[i]| < 14*2^54 */
+ freduce_degree(xxprime);
+ freduce_coefficients(xxprime);
+ /* |xxprime[i]| < 2^26 */
+ freduce_degree(zzprime);
+ freduce_coefficients(zzprime);
+ /* |zzprime[i]| < 2^26 */
+ memcpy(origxprime, xxprime, sizeof(limb) * 10);
+ fsum(xxprime, zzprime);
+ /* |xxprime[i]| < 2^27 */
+ fdifference(zzprime, origxprime);
+ /* |zzprime[i]| < 2^27 */
+ fsquare(xxxprime, xxprime);
+ /* |xxxprime[i]| < 2^26 */
+ fsquare(zzzprime, zzprime);
+ /* |zzzprime[i]| < 2^26 */
+ fproduct(zzprime, zzzprime, qmqp);
+ /* |zzprime[i]| < 14*2^52 */
+ freduce_degree(zzprime);
+ freduce_coefficients(zzprime);
+ /* |zzprime[i]| < 2^26 */
+ memcpy(x3, xxxprime, sizeof(limb) * 10);
+ memcpy(z3, zzprime, sizeof(limb) * 10);
+
+ fsquare(xx, x);
+ /* |xx[i]| < 2^26 */
+ fsquare(zz, z);
+ /* |zz[i]| < 2^26 */
+ fproduct(x2, xx, zz);
+ /* |x2[i]| < 14*2^52 */
+ freduce_degree(x2);
+ freduce_coefficients(x2);
+ /* |x2[i]| < 2^26 */
+ fdifference(zz, xx); // does zz = xx - zz
+ /* |zz[i]| < 2^27 */
+ memset(zzz + 10, 0, sizeof(limb) * 9);
+ fscalar_product(zzz, zz, 121665);
+ /* |zzz[i]| < 2^(27+17) */
+ /* No need to call freduce_degree here:
+ fscalar_product doesn't increase the degree of its input. */
+ freduce_coefficients(zzz);
+ /* |zzz[i]| < 2^26 */
+ fsum(zzz, xx);
+ /* |zzz[i]| < 2^27 */
+ fproduct(z2, zz, zzz);
+ /* |z2[i]| < 14*2^(26+27) */
+ freduce_degree(z2);
+ freduce_coefficients(z2);
+ /* |z2|i| < 2^26 */
+}
+
+/* Conditionally swap two reduced-form limb arrays if 'iswap' is 1, but leave
+ * them unchanged if 'iswap' is 0. Runs in data-invariant time to avoid
+ * side-channel attacks.
+ *
+ * NOTE that this function requires that 'iswap' be 1 or 0; other values give
+ * wrong results. Also, the two limb arrays must be in reduced-coefficient,
+ * reduced-degree form: the values in a[10..19] or b[10..19] aren't swapped,
+ * and all all values in a[0..9],b[0..9] must have magnitude less than
+ * INT32_MAX. */
+static void
+swap_conditional(limb a[19], limb b[19], limb iswap) {
+ unsigned i;
+ const s32 swap = (s32) -iswap;
+
+ for (i = 0; i < 10; ++i) {
+ const s32 x = swap & ( ((s32)a[i]) ^ ((s32)b[i]) );
+ a[i] = ((s32)a[i]) ^ x;
+ b[i] = ((s32)b[i]) ^ x;
+ }
+}
+
+/* Calculates nQ where Q is the x-coordinate of a point on the curve
+ *
+ * resultx/resultz: the x coordinate of the resulting curve point (short form)
+ * n: a little endian, 32-byte number
+ * q: a point of the curve (short form) */
+static void
+cmult(limb *resultx, limb *resultz, const u8 *n, const limb *q) {
+ limb a[19] = {0}, b[19] = {1}, c[19] = {1}, d[19] = {0};
+ limb *nqpqx = a, *nqpqz = b, *nqx = c, *nqz = d, *t;
+ limb e[19] = {0}, f[19] = {1}, g[19] = {0}, h[19] = {1};
+ limb *nqpqx2 = e, *nqpqz2 = f, *nqx2 = g, *nqz2 = h;
+
+ unsigned i, j;
+
+ memcpy(nqpqx, q, sizeof(limb) * 10);
+
+ for (i = 0; i < 32; ++i) {
+ u8 byte = n[31 - i];
+ for (j = 0; j < 8; ++j) {
+ const limb bit = byte >> 7;
+
+ swap_conditional(nqx, nqpqx, bit);
+ swap_conditional(nqz, nqpqz, bit);
+ fmonty(nqx2, nqz2,
+ nqpqx2, nqpqz2,
+ nqx, nqz,
+ nqpqx, nqpqz,
+ q);
+ swap_conditional(nqx2, nqpqx2, bit);
+ swap_conditional(nqz2, nqpqz2, bit);
+
+ t = nqx;
+ nqx = nqx2;
+ nqx2 = t;
+ t = nqz;
+ nqz = nqz2;
+ nqz2 = t;
+ t = nqpqx;
+ nqpqx = nqpqx2;
+ nqpqx2 = t;
+ t = nqpqz;
+ nqpqz = nqpqz2;
+ nqpqz2 = t;
+
+ byte <<= 1;
+ }
+ }
+
+ memcpy(resultx, nqx, sizeof(limb) * 10);
+ memcpy(resultz, nqz, sizeof(limb) * 10);
+}
+
+// -----------------------------------------------------------------------------
+// Shamelessly copied from djb's code
+// -----------------------------------------------------------------------------
+static void
+crecip(limb *out, const limb *z) {
+ limb z2[10];
+ limb z9[10];
+ limb z11[10];
+ limb z2_5_0[10];
+ limb z2_10_0[10];
+ limb z2_20_0[10];
+ limb z2_50_0[10];
+ limb z2_100_0[10];
+ limb t0[10];
+ limb t1[10];
+ int i;
+
+ /* 2 */ fsquare(z2,z);
+ /* 4 */ fsquare(t1,z2);
+ /* 8 */ fsquare(t0,t1);
+ /* 9 */ fmul(z9,t0,z);
+ /* 11 */ fmul(z11,z9,z2);
+ /* 22 */ fsquare(t0,z11);
+ /* 2^5 - 2^0 = 31 */ fmul(z2_5_0,t0,z9);
+
+ /* 2^6 - 2^1 */ fsquare(t0,z2_5_0);
+ /* 2^7 - 2^2 */ fsquare(t1,t0);
+ /* 2^8 - 2^3 */ fsquare(t0,t1);
+ /* 2^9 - 2^4 */ fsquare(t1,t0);
+ /* 2^10 - 2^5 */ fsquare(t0,t1);
+ /* 2^10 - 2^0 */ fmul(z2_10_0,t0,z2_5_0);
+
+ /* 2^11 - 2^1 */ fsquare(t0,z2_10_0);
+ /* 2^12 - 2^2 */ fsquare(t1,t0);
+ /* 2^20 - 2^10 */ for (i = 2;i < 10;i += 2) { fsquare(t0,t1); fsquare(t1,t0); }
+ /* 2^20 - 2^0 */ fmul(z2_20_0,t1,z2_10_0);
+
+ /* 2^21 - 2^1 */ fsquare(t0,z2_20_0);
+ /* 2^22 - 2^2 */ fsquare(t1,t0);
+ /* 2^40 - 2^20 */ for (i = 2;i < 20;i += 2) { fsquare(t0,t1); fsquare(t1,t0); }
+ /* 2^40 - 2^0 */ fmul(t0,t1,z2_20_0);
+
+ /* 2^41 - 2^1 */ fsquare(t1,t0);
+ /* 2^42 - 2^2 */ fsquare(t0,t1);
+ /* 2^50 - 2^10 */ for (i = 2;i < 10;i += 2) { fsquare(t1,t0); fsquare(t0,t1); }
+ /* 2^50 - 2^0 */ fmul(z2_50_0,t0,z2_10_0);
+
+ /* 2^51 - 2^1 */ fsquare(t0,z2_50_0);
+ /* 2^52 - 2^2 */ fsquare(t1,t0);
+ /* 2^100 - 2^50 */ for (i = 2;i < 50;i += 2) { fsquare(t0,t1); fsquare(t1,t0); }
+ /* 2^100 - 2^0 */ fmul(z2_100_0,t1,z2_50_0);
+
+ /* 2^101 - 2^1 */ fsquare(t1,z2_100_0);
+ /* 2^102 - 2^2 */ fsquare(t0,t1);
+ /* 2^200 - 2^100 */ for (i = 2;i < 100;i += 2) { fsquare(t1,t0); fsquare(t0,t1); }
+ /* 2^200 - 2^0 */ fmul(t1,t0,z2_100_0);
+
+ /* 2^201 - 2^1 */ fsquare(t0,t1);
+ /* 2^202 - 2^2 */ fsquare(t1,t0);
+ /* 2^250 - 2^50 */ for (i = 2;i < 50;i += 2) { fsquare(t0,t1); fsquare(t1,t0); }
+ /* 2^250 - 2^0 */ fmul(t0,t1,z2_50_0);
+
+ /* 2^251 - 2^1 */ fsquare(t1,t0);
+ /* 2^252 - 2^2 */ fsquare(t0,t1);
+ /* 2^253 - 2^3 */ fsquare(t1,t0);
+ /* 2^254 - 2^4 */ fsquare(t0,t1);
+ /* 2^255 - 2^5 */ fsquare(t1,t0);
+ /* 2^255 - 21 */ fmul(out,t1,z11);
+}
+
+int
+curve25519_donna(u8 *mypublic, const u8 *secret, const u8 *basepoint) {
+ limb bp[10], x[10], z[11], zmone[10];
+ uint8_t e[32];
+ int i;
+
+ for (i = 0; i < 32; ++i) e[i] = secret[i];
+// e[0] &= 248;
+// e[31] &= 127;
+// e[31] |= 64;
+
+ fexpand(bp, basepoint);
+ cmult(x, z, e, bp);
+ crecip(zmone, z);
+ fmul(z, x, zmone);
+ fcontract(mypublic, z);
+ return 0;
+}
diff --git a/jni/curve25519-donna.h b/jni/curve25519-donna.h
new file mode 100644
index 00000000..3e4dfcee
--- /dev/null
+++ b/jni/curve25519-donna.h
@@ -0,0 +1,6 @@
+#ifndef CURVE25519_DONNA_H
+#define CURVE25519_DONNA_H
+
+extern int curve25519_donna(uint8_t *, const uint8_t *, const uint8_t *);
+
+#endif
diff --git a/jni/curve25519-jni.c b/jni/curve25519-jni.c
new file mode 100644
index 00000000..5d058a91
--- /dev/null
+++ b/jni/curve25519-jni.c
@@ -0,0 +1,109 @@
+/**
+ * Copyright (C) 2013-2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <string.h>
+#include <stdint.h>
+
+#include <jni.h>
+#include "curve25519-donna.h"
+#include "curve_sigs.h"
+
+JNIEXPORT jbyteArray JNICALL Java_org_whispersystems_libaxolotl_ecc_Curve25519_generatePrivateKey
+ (JNIEnv *env, jclass clazz, jbyteArray random)
+{
+ uint8_t* privateKey = (uint8_t*)(*env)->GetByteArrayElements(env, random, 0);
+
+ privateKey[0] &= 248;
+ privateKey[31] &= 127;
+ privateKey[31] |= 64;
+
+ (*env)->ReleaseByteArrayElements(env, random, privateKey, 0);
+
+ return random;
+}
+
+JNIEXPORT jbyteArray JNICALL Java_org_whispersystems_libaxolotl_ecc_Curve25519_generatePublicKey
+ (JNIEnv *env, jclass clazz, jbyteArray privateKey)
+{
+ static const uint8_t basepoint[32] = {9};
+
+ jbyteArray publicKey = (*env)->NewByteArray(env, 32);
+ uint8_t* publicKeyBytes = (uint8_t*)(*env)->GetByteArrayElements(env, publicKey, 0);
+ uint8_t* privateKeyBytes = (uint8_t*)(*env)->GetByteArrayElements(env, privateKey, 0);
+
+ curve25519_donna(publicKeyBytes, privateKeyBytes, basepoint);
+
+ (*env)->ReleaseByteArrayElements(env, publicKey, publicKeyBytes, 0);
+ (*env)->ReleaseByteArrayElements(env, privateKey, privateKeyBytes, 0);
+
+ return publicKey;
+}
+
+JNIEXPORT jbyteArray JNICALL Java_org_whispersystems_libaxolotl_ecc_Curve25519_calculateAgreement
+ (JNIEnv *env, jclass clazz, jbyteArray privateKey, jbyteArray publicKey)
+{
+ jbyteArray sharedKey = (*env)->NewByteArray(env, 32);
+ uint8_t* sharedKeyBytes = (uint8_t*)(*env)->GetByteArrayElements(env, sharedKey, 0);
+ uint8_t* privateKeyBytes = (uint8_t*)(*env)->GetByteArrayElements(env, privateKey, 0);
+ uint8_t* publicKeyBytes = (uint8_t*)(*env)->GetByteArrayElements(env, publicKey, 0);
+
+ curve25519_donna(sharedKeyBytes, privateKeyBytes, publicKeyBytes);
+
+ (*env)->ReleaseByteArrayElements(env, sharedKey, sharedKeyBytes, 0);
+ (*env)->ReleaseByteArrayElements(env, publicKey, publicKeyBytes, 0);
+ (*env)->ReleaseByteArrayElements(env, privateKey, privateKeyBytes, 0);
+
+ return sharedKey;
+}
+
+JNIEXPORT jbyteArray JNICALL Java_org_whispersystems_libaxolotl_ecc_Curve25519_calculateSignature
+ (JNIEnv *env, jclass clazz, jbyteArray random, jbyteArray privateKey, jbyteArray message)
+{
+ jbyteArray signature = (*env)->NewByteArray(env, 64);
+ uint8_t* signatureBytes = (uint8_t*)(*env)->GetByteArrayElements(env, signature, 0);
+ uint8_t* randomBytes = (uint8_t*)(*env)->GetByteArrayElements(env, random, 0);
+ uint8_t* privateKeyBytes = (uint8_t*)(*env)->GetByteArrayElements(env, privateKey, 0);
+ uint8_t* messageBytes = (uint8_t*)(*env)->GetByteArrayElements(env, message, 0);
+ jsize messageLength = (*env)->GetArrayLength(env, message);
+
+ int result = curve25519_sign(signatureBytes, privateKeyBytes, messageBytes, messageLength, randomBytes);
+
+ (*env)->ReleaseByteArrayElements(env, signature, signatureBytes, 0);
+ (*env)->ReleaseByteArrayElements(env, random, randomBytes, 0);
+ (*env)->ReleaseByteArrayElements(env, privateKey, privateKeyBytes, 0);
+ (*env)->ReleaseByteArrayElements(env, message, messageBytes, 0);
+
+ if (result == 0) return signature;
+ else (*env)->ThrowNew(env, (*env)->FindClass(env, "java/lang/AssertionError"), "Signature failed!");
+}
+
+JNIEXPORT jboolean JNICALL Java_org_whispersystems_libaxolotl_ecc_Curve25519_verifySignature
+ (JNIEnv *env, jclass clazz, jbyteArray publicKey, jbyteArray message, jbyteArray signature)
+{
+ uint8_t* signatureBytes = (uint8_t*)(*env)->GetByteArrayElements(env, signature, 0);
+ uint8_t* publicKeyBytes = (uint8_t*)(*env)->GetByteArrayElements(env, publicKey, 0);
+ uint8_t* messageBytes = (uint8_t*)(*env)->GetByteArrayElements(env, message, 0);
+ jsize messageLength = (*env)->GetArrayLength(env, message);
+
+ jboolean result = (curve25519_verify(signatureBytes, publicKeyBytes, messageBytes, messageLength) == 0);
+
+ (*env)->ReleaseByteArrayElements(env, signature, signatureBytes, 0);
+ (*env)->ReleaseByteArrayElements(env, publicKey, publicKeyBytes, 0);
+ (*env)->ReleaseByteArrayElements(env, message, messageBytes, 0);
+
+ return result;
+}
diff --git a/jni/ed25519/additions/compare.c b/jni/ed25519/additions/compare.c
new file mode 100644
index 00000000..8b1e3138
--- /dev/null
+++ b/jni/ed25519/additions/compare.c
@@ -0,0 +1,44 @@
+#include <string.h>
+#include "compare.h"
+
+/* Const-time comparison from SUPERCOP, but here it's only used for
+ signature verification, so doesn't need to be const-time. But
+ copied the nacl version anyways. */
+int crypto_verify_32_ref(const unsigned char *x, const unsigned char *y)
+{
+ unsigned int differentbits = 0;
+#define F(i) differentbits |= x[i] ^ y[i];
+ F(0)
+ F(1)
+ F(2)
+ F(3)
+ F(4)
+ F(5)
+ F(6)
+ F(7)
+ F(8)
+ F(9)
+ F(10)
+ F(11)
+ F(12)
+ F(13)
+ F(14)
+ F(15)
+ F(16)
+ F(17)
+ F(18)
+ F(19)
+ F(20)
+ F(21)
+ F(22)
+ F(23)
+ F(24)
+ F(25)
+ F(26)
+ F(27)
+ F(28)
+ F(29)
+ F(30)
+ F(31)
+ return (1 & ((differentbits - 1) >> 8)) - 1;
+}
diff --git a/jni/ed25519/additions/compare.h b/jni/ed25519/additions/compare.h
new file mode 100644
index 00000000..5a2fa910
--- /dev/null
+++ b/jni/ed25519/additions/compare.h
@@ -0,0 +1,6 @@
+#ifndef __COMPARE_H__
+#define __COMPARE_H__
+
+int crypto_verify_32_ref(const unsigned char *b1, const unsigned char *b2);
+
+#endif
diff --git a/jni/ed25519/additions/crypto_hash_sha512.h b/jni/ed25519/additions/crypto_hash_sha512.h
new file mode 100644
index 00000000..a51a190d
--- /dev/null
+++ b/jni/ed25519/additions/crypto_hash_sha512.h
@@ -0,0 +1,6 @@
+#ifndef crypto_hash_sha512_H
+#define crypto_hash_sha512_H
+
+extern int crypto_hash_sha512(unsigned char *,const unsigned char *,unsigned long long);
+
+#endif
diff --git a/jni/ed25519/additions/curve_sigs.c b/jni/ed25519/additions/curve_sigs.c
new file mode 100644
index 00000000..51f2052d
--- /dev/null
+++ b/jni/ed25519/additions/curve_sigs.c
@@ -0,0 +1,116 @@
+#include <string.h>
+#include "ge.h"
+#include "curve_sigs.h"
+#include "crypto_sign.h"
+
+void curve25519_keygen(unsigned char* curve25519_pubkey_out,
+ const unsigned char* curve25519_privkey_in)
+{
+ ge_p3 ed; /* Ed25519 pubkey point */
+ fe ed_y, ed_y_plus_one, one_minus_ed_y, inv_one_minus_ed_y;
+ fe mont_x;
+
+ /* Perform a fixed-base multiplication of the Edwards base point,
+ (which is efficient due to precalculated tables), then convert
+ to the Curve25519 montgomery-format public key. In particular,
+ convert Curve25519's "montgomery" x-coordinate into an Ed25519
+ "edwards" y-coordinate:
+
+ mont_x = (ed_y + 1) / (1 - ed_y)
+
+ with projective coordinates:
+
+ mont_x = (ed_y + ed_z) / (ed_z - ed_y)
+
+ NOTE: ed_y=1 is converted to mont_x=0 since fe_invert is mod-exp
+ */
+
+ ge_scalarmult_base(&ed, curve25519_privkey_in);
+ fe_add(ed_y_plus_one, ed.Y, ed.Z);
+ fe_sub(one_minus_ed_y, ed.Z, ed.Y);
+ fe_invert(inv_one_minus_ed_y, one_minus_ed_y);
+ fe_mul(mont_x, ed_y_plus_one, inv_one_minus_ed_y);
+ fe_tobytes(curve25519_pubkey_out, mont_x);
+}
+
+int curve25519_sign(unsigned char* signature_out,
+ const unsigned char* curve25519_privkey,
+ const unsigned char* msg, const unsigned long msg_len,
+ const unsigned char* random)
+{
+ ge_p3 ed_pubkey_point; /* Ed25519 pubkey point */
+ unsigned char ed_pubkey[32]; /* Ed25519 encoded pubkey */
+ unsigned char sigbuf[MAX_MSG_LEN + 128]; /* working buffer */
+ unsigned char sign_bit = 0;
+
+ if (msg_len > MAX_MSG_LEN) {
+ memset(signature_out, 0, 64);
+ return -1;
+ }
+
+ /* Convert the Curve25519 privkey to an Ed25519 public key */
+ ge_scalarmult_base(&ed_pubkey_point, curve25519_privkey);
+ ge_p3_tobytes(ed_pubkey, &ed_pubkey_point);
+ sign_bit = ed_pubkey[31] & 0x80;
+
+ /* Perform an Ed25519 signature with explicit private key */
+ crypto_sign_modified(sigbuf, msg, msg_len, curve25519_privkey,
+ ed_pubkey, random);
+ memmove(signature_out, sigbuf, 64);
+
+ /* Encode the sign bit into signature (in unused high bit of S) */
+ signature_out[63] &= 0x7F; /* bit should be zero already, but just in case */
+ signature_out[63] |= sign_bit;
+ return 0;
+}
+
+int curve25519_verify(const unsigned char* signature,
+ const unsigned char* curve25519_pubkey,
+ const unsigned char* msg, const unsigned long msg_len)
+{
+ fe mont_x, mont_x_minus_one, mont_x_plus_one, inv_mont_x_plus_one;
+ fe one;
+ fe ed_y;
+ unsigned char ed_pubkey[32];
+ unsigned long long some_retval;
+ unsigned char verifybuf[MAX_MSG_LEN + 64]; /* working buffer */
+ unsigned char verifybuf2[MAX_MSG_LEN + 64]; /* working buffer #2 */
+
+ if (msg_len > MAX_MSG_LEN) {
+ return -1;
+ }
+
+ /* Convert the Curve25519 public key into an Ed25519 public key. In
+ particular, convert Curve25519's "montgomery" x-coordinate into an
+ Ed25519 "edwards" y-coordinate:
+
+ ed_y = (mont_x - 1) / (mont_x + 1)
+
+ NOTE: mont_x=-1 is converted to ed_y=0 since fe_invert is mod-exp
+
+ Then move the sign bit into the pubkey from the signature.
+ */
+ fe_frombytes(mont_x, curve25519_pubkey);
+ fe_1(one);
+ fe_sub(mont_x_minus_one, mont_x, one);
+ fe_add(mont_x_plus_one, mont_x, one);
+ fe_invert(inv_mont_x_plus_one, mont_x_plus_one);
+ fe_mul(ed_y, mont_x_minus_one, inv_mont_x_plus_one);
+ fe_tobytes(ed_pubkey, ed_y);
+
+ /* Copy the sign bit, and remove it from signature */
+ ed_pubkey[31] &= 0x7F; /* bit should be zero already, but just in case */
+ ed_pubkey[31] |= (signature[63] & 0x80);
+ memmove(verifybuf, signature, 64);
+ verifybuf[63] &= 0x7F;
+
+ memmove(verifybuf+64, msg, msg_len);
+
+ /* Then perform a normal Ed25519 verification, return 0 on success */
+ /* The below call has a strange API: */
+ /* verifybuf = R || S || message */
+ /* verifybuf2 = internal to next call gets a copy of verifybuf, S gets
+ replaced with pubkey for hashing, then the whole thing gets zeroized
+ (if bad sig), or contains a copy of msg (good sig) */
+ return crypto_sign_open(verifybuf2, &some_retval, verifybuf, 64 + msg_len, ed_pubkey);
+}
diff --git a/jni/ed25519/additions/curve_sigs.h b/jni/ed25519/additions/curve_sigs.h
new file mode 100644
index 00000000..cc462471
--- /dev/null
+++ b/jni/ed25519/additions/curve_sigs.h
@@ -0,0 +1,50 @@
+
+#ifndef __CURVE_SIGS_H__
+#define __CURVE_SIGS_H__
+
+#define MAX_MSG_LEN 256
+
+void curve25519_keygen(unsigned char* curve25519_pubkey_out, /* 32 bytes */
+ const unsigned char* curve25519_privkey_in); /* 32 bytes */
+
+/* returns 0 on success */
+int curve25519_sign(unsigned char* signature_out, /* 64 bytes */
+ const unsigned char* curve25519_privkey, /* 32 bytes */
+ const unsigned char* msg, const unsigned long msg_len,
+ const unsigned char* random); /* 64 bytes */
+
+/* returns 0 on success */
+int curve25519_verify(const unsigned char* signature, /* 64 bytes */
+ const unsigned char* curve25519_pubkey, /* 32 bytes */
+ const unsigned char* msg, const unsigned long msg_len);
+
+/* helper function - modified version of crypto_sign() to use
+ explicit private key. In particular:
+
+ sk : private key
+ pk : public key
+ msg : message
+ prefix : 0xFE || [0xFF]*31
+ random : 64 bytes random
+ q : main subgroup order
+
+ The prefix is chosen to distinguish the two SHA512 uses below, since
+ prefix is an invalid encoding for R (it would encode a "field element"
+ of 2^255 - 2). 0xFF*32 is set aside for use in ECDH protocols, which
+ is why the first byte here ix 0xFE.
+
+ sig_nonce = SHA512(prefix || sk || msg || random) % q
+ R = g^sig_nonce
+ M = SHA512(R || pk || m)
+ S = sig_nonce + (m * sk)
+ signature = (R || S)
+ */
+int crypto_sign_modified(
+ unsigned char *sm,
+ const unsigned char *m,unsigned long long mlen,
+ const unsigned char *sk, /* Curve/Ed25519 private key */
+ const unsigned char *pk, /* Ed25519 public key */
+ const unsigned char *random /* 64 bytes random to hash into nonce */
+ );
+
+#endif
diff --git a/jni/ed25519/additions/sign_modified.c b/jni/ed25519/additions/sign_modified.c
new file mode 100644
index 00000000..61332e70
--- /dev/null
+++ b/jni/ed25519/additions/sign_modified.c
@@ -0,0 +1,47 @@
+#include <string.h>
+#include "crypto_sign.h"
+#include "crypto_hash_sha512.h"
+#include "ge.h"
+#include "sc.h"
+#include "zeroize.h"
+
+/* NEW: Compare to pristine crypto_sign()
+ Uses explicit private key for nonce derivation and as scalar,
+ instead of deriving both from a master key.
+*/
+int crypto_sign_modified(
+ unsigned char *sm,
+ const unsigned char *m,unsigned long long mlen,
+ const unsigned char *sk, const unsigned char* pk,
+ const unsigned char* random
+)
+{
+ unsigned char nonce[64];
+ unsigned char hram[64];
+ ge_p3 R;
+ int count=0;
+
+ memmove(sm + 64,m,mlen);
+ memmove(sm + 32,sk,32); /* NEW: Use privkey directly for nonce derivation */
+
+ /* NEW : add prefix to separate hash uses - see .h */
+ sm[0] = 0xFE;
+ for (count = 1; count < 32; count++)
+ sm[count] = 0xFF;
+
+ /* NEW: add suffix of random data */
+ memmove(sm + mlen + 64, random, 64);
+
+ crypto_hash_sha512(nonce,sm,mlen + 128);
+ memmove(sm + 32,pk,32);
+
+ sc_reduce(nonce);
+ ge_scalarmult_base(&R,nonce);
+ ge_p3_tobytes(sm,&R);
+
+ crypto_hash_sha512(hram,sm,mlen + 64);
+ sc_reduce(hram);
+ sc_muladd(sm + 32,hram,sk,nonce); /* NEW: Use privkey directly */
+
+ return 0;
+}
diff --git a/jni/ed25519/additions/zeroize.c b/jni/ed25519/additions/zeroize.c
new file mode 100644
index 00000000..37c1f708
--- /dev/null
+++ b/jni/ed25519/additions/zeroize.c
@@ -0,0 +1,17 @@
+#include "zeroize.h"
+
+void zeroize(unsigned char* b, size_t len)
+{
+ size_t count = 0;
+ unsigned long retval = 0;
+ volatile unsigned char *p = b;
+
+ for (count = 0; count < len; count++)
+ p[count] = 0;
+}
+
+void zeroize_stack()
+{
+ unsigned char m[ZEROIZE_STACK_SIZE];
+ zeroize(m, sizeof m);
+}
diff --git a/jni/ed25519/additions/zeroize.h b/jni/ed25519/additions/zeroize.h
new file mode 100644
index 00000000..80fcffb7
--- /dev/null
+++ b/jni/ed25519/additions/zeroize.h
@@ -0,0 +1,12 @@
+#ifndef __ZEROIZE_H__
+#define __ZEROIZE_H__
+
+#include <stdlib.h>
+
+#define ZEROIZE_STACK_SIZE 2048
+
+void zeroize(unsigned char* b, size_t len);
+
+void zeroize_stack();
+
+#endif
diff --git a/jni/ed25519/api.h b/jni/ed25519/api.h
new file mode 100644
index 00000000..d88dae0c
--- /dev/null
+++ b/jni/ed25519/api.h
@@ -0,0 +1,4 @@
+#define CRYPTO_SECRETKEYBYTES 64
+#define CRYPTO_PUBLICKEYBYTES 32
+#define CRYPTO_BYTES 64
+#define CRYPTO_DETERMINISTIC 1
diff --git a/jni/ed25519/base.h b/jni/ed25519/base.h
new file mode 100644
index 00000000..573bd8a0
--- /dev/null
+++ b/jni/ed25519/base.h
@@ -0,0 +1,1344 @@
+{
+ {
+ { 25967493,-14356035,29566456,3660896,-12694345,4014787,27544626,-11754271,-6079156,2047605 },
+ { -12545711,934262,-2722910,3049990,-727428,9406986,12720692,5043384,19500929,-15469378 },
+ { -8738181,4489570,9688441,-14785194,10184609,-12363380,29287919,11864899,-24514362,-4438546 },
+ },
+ {
+ { -12815894,-12976347,-21581243,11784320,-25355658,-2750717,-11717903,-3814571,-358445,-10211303 },
+ { -21703237,6903825,27185491,6451973,-29577724,-9554005,-15616551,11189268,-26829678,-5319081 },
+ { 26966642,11152617,32442495,15396054,14353839,-12752335,-3128826,-9541118,-15472047,-4166697 },
+ },
+ {
+ { 15636291,-9688557,24204773,-7912398,616977,-16685262,27787600,-14772189,28944400,-1550024 },
+ { 16568933,4717097,-11556148,-1102322,15682896,-11807043,16354577,-11775962,7689662,11199574 },
+ { 30464156,-5976125,-11779434,-15670865,23220365,15915852,7512774,10017326,-17749093,-9920357 },
+ },
+ {
+ { -17036878,13921892,10945806,-6033431,27105052,-16084379,-28926210,15006023,3284568,-6276540 },
+ { 23599295,-8306047,-11193664,-7687416,13236774,10506355,7464579,9656445,13059162,10374397 },
+ { 7798556,16710257,3033922,2874086,28997861,2835604,32406664,-3839045,-641708,-101325 },
+ },
+ {
+ { 10861363,11473154,27284546,1981175,-30064349,12577861,32867885,14515107,-15438304,10819380 },
+ { 4708026,6336745,20377586,9066809,-11272109,6594696,-25653668,12483688,-12668491,5581306 },
+ { 19563160,16186464,-29386857,4097519,10237984,-4348115,28542350,13850243,-23678021,-15815942 },
+ },
+ {
+ { -15371964,-12862754,32573250,4720197,-26436522,5875511,-19188627,-15224819,-9818940,-12085777 },
+ { -8549212,109983,15149363,2178705,22900618,4543417,3044240,-15689887,1762328,14866737 },
+ { -18199695,-15951423,-10473290,1707278,-17185920,3916101,-28236412,3959421,27914454,4383652 },
+ },
+ {
+ { 5153746,9909285,1723747,-2777874,30523605,5516873,19480852,5230134,-23952439,-15175766 },
+ { -30269007,-3463509,7665486,10083793,28475525,1649722,20654025,16520125,30598449,7715701 },
+ { 28881845,14381568,9657904,3680757,-20181635,7843316,-31400660,1370708,29794553,-1409300 },
+ },
+ {
+ { 14499471,-2729599,-33191113,-4254652,28494862,14271267,30290735,10876454,-33154098,2381726 },
+ { -7195431,-2655363,-14730155,462251,-27724326,3941372,-6236617,3696005,-32300832,15351955 },
+ { 27431194,8222322,16448760,-3907995,-18707002,11938355,-32961401,-2970515,29551813,10109425 },
+ },
+},
+{
+ {
+ { -13657040,-13155431,-31283750,11777098,21447386,6519384,-2378284,-1627556,10092783,-4764171 },
+ { 27939166,14210322,4677035,16277044,-22964462,-12398139,-32508754,12005538,-17810127,12803510 },
+ { 17228999,-15661624,-1233527,300140,-1224870,-11714777,30364213,-9038194,18016357,4397660 },
+ },
+ {
+ { -10958843,-7690207,4776341,-14954238,27850028,-15602212,-26619106,14544525,-17477504,982639 },
+ { 29253598,15796703,-2863982,-9908884,10057023,3163536,7332899,-4120128,-21047696,9934963 },
+ { 5793303,16271923,-24131614,-10116404,29188560,1206517,-14747930,4559895,-30123922,-10897950 },
+ },
+ {
+ { -27643952,-11493006,16282657,-11036493,28414021,-15012264,24191034,4541697,-13338309,5500568 },
+ { 12650548,-1497113,9052871,11355358,-17680037,-8400164,-17430592,12264343,10874051,13524335 },
+ { 25556948,-3045990,714651,2510400,23394682,-10415330,33119038,5080568,-22528059,5376628 },
+ },
+ {
+ { -26088264,-4011052,-17013699,-3537628,-6726793,1920897,-22321305,-9447443,4535768,1569007 },
+ { -2255422,14606630,-21692440,-8039818,28430649,8775819,-30494562,3044290,31848280,12543772 },
+ { -22028579,2943893,-31857513,6777306,13784462,-4292203,-27377195,-2062731,7718482,14474653 },
+ },
+ {
+ { 2385315,2454213,-22631320,46603,-4437935,-15680415,656965,-7236665,24316168,-5253567 },
+ { 13741529,10911568,-33233417,-8603737,-20177830,-1033297,33040651,-13424532,-20729456,8321686 },
+ { 21060490,-2212744,15712757,-4336099,1639040,10656336,23845965,-11874838,-9984458,608372 },
+ },
+ {
+ { -13672732,-15087586,-10889693,-7557059,-6036909,11305547,1123968,-6780577,27229399,23887 },
+ { -23244140,-294205,-11744728,14712571,-29465699,-2029617,12797024,-6440308,-1633405,16678954 },
+ { -29500620,4770662,-16054387,14001338,7830047,9564805,-1508144,-4795045,-17169265,4904953 },
+ },
+ {
+ { 24059557,14617003,19037157,-15039908,19766093,-14906429,5169211,16191880,2128236,-4326833 },
+ { -16981152,4124966,-8540610,-10653797,30336522,-14105247,-29806336,916033,-6882542,-2986532 },
+ { -22630907,12419372,-7134229,-7473371,-16478904,16739175,285431,2763829,15736322,4143876 },
+ },
+ {
+ { 2379352,11839345,-4110402,-5988665,11274298,794957,212801,-14594663,23527084,-16458268 },
+ { 33431127,-11130478,-17838966,-15626900,8909499,8376530,-32625340,4087881,-15188911,-14416214 },
+ { 1767683,7197987,-13205226,-2022635,-13091350,448826,5799055,4357868,-4774191,-16323038 },
+ },
+},
+{
+ {
+ { 6721966,13833823,-23523388,-1551314,26354293,-11863321,23365147,-3949732,7390890,2759800 },
+ { 4409041,2052381,23373853,10530217,7676779,-12885954,21302353,-4264057,1244380,-12919645 },
+ { -4421239,7169619,4982368,-2957590,30256825,-2777540,14086413,9208236,15886429,16489664 },
+ },
+ {
+ { 1996075,10375649,14346367,13311202,-6874135,-16438411,-13693198,398369,-30606455,-712933 },
+ { -25307465,9795880,-2777414,14878809,-33531835,14780363,13348553,12076947,-30836462,5113182 },
+ { -17770784,11797796,31950843,13929123,-25888302,12288344,-30341101,-7336386,13847711,5387222 },
+ },
+ {
+ { -18582163,-3416217,17824843,-2340966,22744343,-10442611,8763061,3617786,-19600662,10370991 },
+ { 20246567,-14369378,22358229,-543712,18507283,-10413996,14554437,-8746092,32232924,16763880 },
+ { 9648505,10094563,26416693,14745928,-30374318,-6472621,11094161,15689506,3140038,-16510092 },
+ },
+ {
+ { -16160072,5472695,31895588,4744994,8823515,10365685,-27224800,9448613,-28774454,366295 },
+ { 19153450,11523972,-11096490,-6503142,-24647631,5420647,28344573,8041113,719605,11671788 },
+ { 8678025,2694440,-6808014,2517372,4964326,11152271,-15432916,-15266516,27000813,-10195553 },
+ },
+ {
+ { -15157904,7134312,8639287,-2814877,-7235688,10421742,564065,5336097,6750977,-14521026 },
+ { 11836410,-3979488,26297894,16080799,23455045,15735944,1695823,-8819122,8169720,16220347 },
+ { -18115838,8653647,17578566,-6092619,-8025777,-16012763,-11144307,-2627664,-5990708,-14166033 },
+ },
+ {
+ { -23308498,-10968312,15213228,-10081214,-30853605,-11050004,27884329,2847284,2655861,1738395 },
+ { -27537433,-14253021,-25336301,-8002780,-9370762,8129821,21651608,-3239336,-19087449,-11005278 },
+ { 1533110,3437855,23735889,459276,29970501,11335377,26030092,5821408,10478196,8544890 },
+ },
+ {
+ { 32173121,-16129311,24896207,3921497,22579056,-3410854,19270449,12217473,17789017,-3395995 },
+ { -30552961,-2228401,-15578829,-10147201,13243889,517024,15479401,-3853233,30460520,1052596 },
+ { -11614875,13323618,32618793,8175907,-15230173,12596687,27491595,-4612359,3179268,-9478891 },
+ },
+ {
+ { 31947069,-14366651,-4640583,-15339921,-15125977,-6039709,-14756777,-16411740,19072640,-9511060 },
+ { 11685058,11822410,3158003,-13952594,33402194,-4165066,5977896,-5215017,473099,5040608 },
+ { -20290863,8198642,-27410132,11602123,1290375,-2799760,28326862,1721092,-19558642,-3131606 },
+ },
+},
+{
+ {
+ { 7881532,10687937,7578723,7738378,-18951012,-2553952,21820786,8076149,-27868496,11538389 },
+ { -19935666,3899861,18283497,-6801568,-15728660,-11249211,8754525,7446702,-5676054,5797016 },
+ { -11295600,-3793569,-15782110,-7964573,12708869,-8456199,2014099,-9050574,-2369172,-5877341 },
+ },
+ {
+ { -22472376,-11568741,-27682020,1146375,18956691,16640559,1192730,-3714199,15123619,10811505 },
+ { 14352098,-3419715,-18942044,10822655,32750596,4699007,-70363,15776356,-28886779,-11974553 },
+ { -28241164,-8072475,-4978962,-5315317,29416931,1847569,-20654173,-16484855,4714547,-9600655 },
+ },
+ {
+ { 15200332,8368572,19679101,15970074,-31872674,1959451,24611599,-4543832,-11745876,12340220 },
+ { 12876937,-10480056,33134381,6590940,-6307776,14872440,9613953,8241152,15370987,9608631 },
+ { -4143277,-12014408,8446281,-391603,4407738,13629032,-7724868,15866074,-28210621,-8814099 },
+ },
+ {
+ { 26660628,-15677655,8393734,358047,-7401291,992988,-23904233,858697,20571223,8420556 },
+ { 14620715,13067227,-15447274,8264467,14106269,15080814,33531827,12516406,-21574435,-12476749 },
+ { 236881,10476226,57258,-14677024,6472998,2466984,17258519,7256740,8791136,15069930 },
+ },
+ {
+ { 1276410,-9371918,22949635,-16322807,-23493039,-5702186,14711875,4874229,-30663140,-2331391 },
+ { 5855666,4990204,-13711848,7294284,-7804282,1924647,-1423175,-7912378,-33069337,9234253 },
+ { 20590503,-9018988,31529744,-7352666,-2706834,10650548,31559055,-11609587,18979186,13396066 },
+ },
+ {
+ { 24474287,4968103,22267082,4407354,24063882,-8325180,-18816887,13594782,33514650,7021958 },
+ { -11566906,-6565505,-21365085,15928892,-26158305,4315421,-25948728,-3916677,-21480480,12868082 },
+ { -28635013,13504661,19988037,-2132761,21078225,6443208,-21446107,2244500,-12455797,-8089383 },
+ },
+ {
+ { -30595528,13793479,-5852820,319136,-25723172,-6263899,33086546,8957937,-15233648,5540521 },
+ { -11630176,-11503902,-8119500,-7643073,2620056,1022908,-23710744,-1568984,-16128528,-14962807 },
+ { 23152971,775386,27395463,14006635,-9701118,4649512,1689819,892185,-11513277,-15205948 },
+ },
+ {
+ { 9770129,9586738,26496094,4324120,1556511,-3550024,27453819,4763127,-19179614,5867134 },
+ { -32765025,1927590,31726409,-4753295,23962434,-16019500,27846559,5931263,-29749703,-16108455 },
+ { 27461885,-2977536,22380810,1815854,-23033753,-3031938,7283490,-15148073,-19526700,7734629 },
+ },
+},
+{
+ {
+ { -8010264,-9590817,-11120403,6196038,29344158,-13430885,7585295,-3176626,18549497,15302069 },
+ { -32658337,-6171222,-7672793,-11051681,6258878,13504381,10458790,-6418461,-8872242,8424746 },
+ { 24687205,8613276,-30667046,-3233545,1863892,-1830544,19206234,7134917,-11284482,-828919 },
+ },
+ {
+ { 11334899,-9218022,8025293,12707519,17523892,-10476071,10243738,-14685461,-5066034,16498837 },
+ { 8911542,6887158,-9584260,-6958590,11145641,-9543680,17303925,-14124238,6536641,10543906 },
+ { -28946384,15479763,-17466835,568876,-1497683,11223454,-2669190,-16625574,-27235709,8876771 },
+ },
+ {
+ { -25742899,-12566864,-15649966,-846607,-33026686,-796288,-33481822,15824474,-604426,-9039817 },
+ { 10330056,70051,7957388,-9002667,9764902,15609756,27698697,-4890037,1657394,3084098 },
+ { 10477963,-7470260,12119566,-13250805,29016247,-5365589,31280319,14396151,-30233575,15272409 },
+ },
+ {
+ { -12288309,3169463,28813183,16658753,25116432,-5630466,-25173957,-12636138,-25014757,1950504 },
+ { -26180358,9489187,11053416,-14746161,-31053720,5825630,-8384306,-8767532,15341279,8373727 },
+ { 28685821,7759505,-14378516,-12002860,-31971820,4079242,298136,-10232602,-2878207,15190420 },
+ },
+ {
+ { -32932876,13806336,-14337485,-15794431,-24004620,10940928,8669718,2742393,-26033313,-6875003 },
+ { -1580388,-11729417,-25979658,-11445023,-17411874,-10912854,9291594,-16247779,-12154742,6048605 },
+ { -30305315,14843444,1539301,11864366,20201677,1900163,13934231,5128323,11213262,9168384 },
+ },
+ {
+ { -26280513,11007847,19408960,-940758,-18592965,-4328580,-5088060,-11105150,20470157,-16398701 },
+ { -23136053,9282192,14855179,-15390078,-7362815,-14408560,-22783952,14461608,14042978,5230683 },
+ { 29969567,-2741594,-16711867,-8552442,9175486,-2468974,21556951,3506042,-5933891,-12449708 },
+ },
+ {
+ { -3144746,8744661,19704003,4581278,-20430686,6830683,-21284170,8971513,-28539189,15326563 },
+ { -19464629,10110288,-17262528,-3503892,-23500387,1355669,-15523050,15300988,-20514118,9168260 },
+ { -5353335,4488613,-23803248,16314347,7780487,-15638939,-28948358,9601605,33087103,-9011387 },
+ },
+ {
+ { -19443170,-15512900,-20797467,-12445323,-29824447,10229461,-27444329,-15000531,-5996870,15664672 },
+ { 23294591,-16632613,-22650781,-8470978,27844204,11461195,13099750,-2460356,18151676,13417686 },
+ { -24722913,-4176517,-31150679,5988919,-26858785,6685065,1661597,-12551441,15271676,-15452665 },
+ },
+},
+{
+ {
+ { 11433042,-13228665,8239631,-5279517,-1985436,-725718,-18698764,2167544,-6921301,-13440182 },
+ { -31436171,15575146,30436815,12192228,-22463353,9395379,-9917708,-8638997,12215110,12028277 },
+ { 14098400,6555944,23007258,5757252,-15427832,-12950502,30123440,4617780,-16900089,-655628 },
+ },
+ {
+ { -4026201,-15240835,11893168,13718664,-14809462,1847385,-15819999,10154009,23973261,-12684474 },
+ { -26531820,-3695990,-1908898,2534301,-31870557,-16550355,18341390,-11419951,32013174,-10103539 },
+ { -25479301,10876443,-11771086,-14625140,-12369567,1838104,21911214,6354752,4425632,-837822 },
+ },
+ {
+ { -10433389,-14612966,22229858,-3091047,-13191166,776729,-17415375,-12020462,4725005,14044970 },
+ { 19268650,-7304421,1555349,8692754,-21474059,-9910664,6347390,-1411784,-19522291,-16109756 },
+ { -24864089,12986008,-10898878,-5558584,-11312371,-148526,19541418,8180106,9282262,10282508 },
+ },
+ {
+ { -26205082,4428547,-8661196,-13194263,4098402,-14165257,15522535,8372215,5542595,-10702683 },
+ { -10562541,14895633,26814552,-16673850,-17480754,-2489360,-2781891,6993761,-18093885,10114655 },
+ { -20107055,-929418,31422704,10427861,-7110749,6150669,-29091755,-11529146,25953725,-106158 },
+ },
+ {
+ { -4234397,-8039292,-9119125,3046000,2101609,-12607294,19390020,6094296,-3315279,12831125 },
+ { -15998678,7578152,5310217,14408357,-33548620,-224739,31575954,6326196,7381791,-2421839 },
+ { -20902779,3296811,24736065,-16328389,18374254,7318640,6295303,8082724,-15362489,12339664 },
+ },
+ {
+ { 27724736,2291157,6088201,-14184798,1792727,5857634,13848414,15768922,25091167,14856294 },
+ { -18866652,8331043,24373479,8541013,-701998,-9269457,12927300,-12695493,-22182473,-9012899 },
+ { -11423429,-5421590,11632845,3405020,30536730,-11674039,-27260765,13866390,30146206,9142070 },
+ },
+ {
+ { 3924129,-15307516,-13817122,-10054960,12291820,-668366,-27702774,9326384,-8237858,4171294 },
+ { -15921940,16037937,6713787,16606682,-21612135,2790944,26396185,3731949,345228,-5462949 },
+ { -21327538,13448259,25284571,1143661,20614966,-8849387,2031539,-12391231,-16253183,-13582083 },
+ },
+ {
+ { 31016211,-16722429,26371392,-14451233,-5027349,14854137,17477601,3842657,28012650,-16405420 },
+ { -5075835,9368966,-8562079,-4600902,-15249953,6970560,-9189873,16292057,-8867157,3507940 },
+ { 29439664,3537914,23333589,6997794,-17555561,-11018068,-15209202,-15051267,-9164929,6580396 },
+ },
+},
+{
+ {
+ { -12185861,-7679788,16438269,10826160,-8696817,-6235611,17860444,-9273846,-2095802,9304567 },
+ { 20714564,-4336911,29088195,7406487,11426967,-5095705,14792667,-14608617,5289421,-477127 },
+ { -16665533,-10650790,-6160345,-13305760,9192020,-1802462,17271490,12349094,26939669,-3752294 },
+ },
+ {
+ { -12889898,9373458,31595848,16374215,21471720,13221525,-27283495,-12348559,-3698806,117887 },
+ { 22263325,-6560050,3984570,-11174646,-15114008,-566785,28311253,5358056,-23319780,541964 },
+ { 16259219,3261970,2309254,-15534474,-16885711,-4581916,24134070,-16705829,-13337066,-13552195 },
+ },
+ {
+ { 9378160,-13140186,-22845982,-12745264,28198281,-7244098,-2399684,-717351,690426,14876244 },
+ { 24977353,-314384,-8223969,-13465086,28432343,-1176353,-13068804,-12297348,-22380984,6618999 },
+ { -1538174,11685646,12944378,13682314,-24389511,-14413193,8044829,-13817328,32239829,-5652762 },
+ },
+ {
+ { -18603066,4762990,-926250,8885304,-28412480,-3187315,9781647,-10350059,32779359,5095274 },
+ { -33008130,-5214506,-32264887,-3685216,9460461,-9327423,-24601656,14506724,21639561,-2630236 },
+ { -16400943,-13112215,25239338,15531969,3987758,-4499318,-1289502,-6863535,17874574,558605 },
+ },
+ {
+ { -13600129,10240081,9171883,16131053,-20869254,9599700,33499487,5080151,2085892,5119761 },
+ { -22205145,-2519528,-16381601,414691,-25019550,2170430,30634760,-8363614,-31999993,-5759884 },
+ { -6845704,15791202,8550074,-1312654,29928809,-12092256,27534430,-7192145,-22351378,12961482 },
+ },
+ {
+ { -24492060,-9570771,10368194,11582341,-23397293,-2245287,16533930,8206996,-30194652,-5159638 },
+ { -11121496,-3382234,2307366,6362031,-135455,8868177,-16835630,7031275,7589640,8945490 },
+ { -32152748,8917967,6661220,-11677616,-1192060,-15793393,7251489,-11182180,24099109,-14456170 },
+ },
+ {
+ { 5019558,-7907470,4244127,-14714356,-26933272,6453165,-19118182,-13289025,-6231896,-10280736 },
+ { 10853594,10721687,26480089,5861829,-22995819,1972175,-1866647,-10557898,-3363451,-6441124 },
+ { -17002408,5906790,221599,-6563147,7828208,-13248918,24362661,-2008168,-13866408,7421392 },
+ },
+ {
+ { 8139927,-6546497,32257646,-5890546,30375719,1886181,-21175108,15441252,28826358,-4123029 },
+ { 6267086,9695052,7709135,-16603597,-32869068,-1886135,14795160,-7840124,13746021,-1742048 },
+ { 28584902,7787108,-6732942,-15050729,22846041,-7571236,-3181936,-363524,4771362,-8419958 },
+ },
+},
+{
+ {
+ { 24949256,6376279,-27466481,-8174608,-18646154,-9930606,33543569,-12141695,3569627,11342593 },
+ { 26514989,4740088,27912651,3697550,19331575,-11472339,6809886,4608608,7325975,-14801071 },
+ { -11618399,-14554430,-24321212,7655128,-1369274,5214312,-27400540,10258390,-17646694,-8186692 },
+ },
+ {
+ { 11431204,15823007,26570245,14329124,18029990,4796082,-31446179,15580664,9280358,-3973687 },
+ { -160783,-10326257,-22855316,-4304997,-20861367,-13621002,-32810901,-11181622,-15545091,4387441 },
+ { -20799378,12194512,3937617,-5805892,-27154820,9340370,-24513992,8548137,20617071,-7482001 },
+ },
+ {
+ { -938825,-3930586,-8714311,16124718,24603125,-6225393,-13775352,-11875822,24345683,10325460 },
+ { -19855277,-1568885,-22202708,8714034,14007766,6928528,16318175,-1010689,4766743,3552007 },
+ { -21751364,-16730916,1351763,-803421,-4009670,3950935,3217514,14481909,10988822,-3994762 },
+ },
+ {
+ { 15564307,-14311570,3101243,5684148,30446780,-8051356,12677127,-6505343,-8295852,13296005 },
+ { -9442290,6624296,-30298964,-11913677,-4670981,-2057379,31521204,9614054,-30000824,12074674 },
+ { 4771191,-135239,14290749,-13089852,27992298,14998318,-1413936,-1556716,29832613,-16391035 },
+ },
+ {
+ { 7064884,-7541174,-19161962,-5067537,-18891269,-2912736,25825242,5293297,-27122660,13101590 },
+ { -2298563,2439670,-7466610,1719965,-27267541,-16328445,32512469,-5317593,-30356070,-4190957 },
+ { -30006540,10162316,-33180176,3981723,-16482138,-13070044,14413974,9515896,19568978,9628812 },
+ },
+ {
+ { 33053803,199357,15894591,1583059,27380243,-4580435,-17838894,-6106839,-6291786,3437740 },
+ { -18978877,3884493,19469877,12726490,15913552,13614290,-22961733,70104,7463304,4176122 },
+ { -27124001,10659917,11482427,-16070381,12771467,-6635117,-32719404,-5322751,24216882,5944158 },
+ },
+ {
+ { 8894125,7450974,-2664149,-9765752,-28080517,-12389115,19345746,14680796,11632993,5847885 },
+ { 26942781,-2315317,9129564,-4906607,26024105,11769399,-11518837,6367194,-9727230,4782140 },
+ { 19916461,-4828410,-22910704,-11414391,25606324,-5972441,33253853,8220911,6358847,-1873857 },
+ },
+ {
+ { 801428,-2081702,16569428,11065167,29875704,96627,7908388,-4480480,-13538503,1387155 },
+ { 19646058,5720633,-11416706,12814209,11607948,12749789,14147075,15156355,-21866831,11835260 },
+ { 19299512,1155910,28703737,14890794,2925026,7269399,26121523,15467869,-26560550,5052483 },
+ },
+},
+{
+ {
+ { -3017432,10058206,1980837,3964243,22160966,12322533,-6431123,-12618185,12228557,-7003677 },
+ { 32944382,14922211,-22844894,5188528,21913450,-8719943,4001465,13238564,-6114803,8653815 },
+ { 22865569,-4652735,27603668,-12545395,14348958,8234005,24808405,5719875,28483275,2841751 },
+ },
+ {
+ { -16420968,-1113305,-327719,-12107856,21886282,-15552774,-1887966,-315658,19932058,-12739203 },
+ { -11656086,10087521,-8864888,-5536143,-19278573,-3055912,3999228,13239134,-4777469,-13910208 },
+ { 1382174,-11694719,17266790,9194690,-13324356,9720081,20403944,11284705,-14013818,3093230 },
+ },
+ {
+ { 16650921,-11037932,-1064178,1570629,-8329746,7352753,-302424,16271225,-24049421,-6691850 },
+ { -21911077,-5927941,-4611316,-5560156,-31744103,-10785293,24123614,15193618,-21652117,-16739389 },
+ { -9935934,-4289447,-25279823,4372842,2087473,10399484,31870908,14690798,17361620,11864968 },
+ },
+ {
+ { -11307610,6210372,13206574,5806320,-29017692,-13967200,-12331205,-7486601,-25578460,-16240689 },
+ { 14668462,-12270235,26039039,15305210,25515617,4542480,10453892,6577524,9145645,-6443880 },
+ { 5974874,3053895,-9433049,-10385191,-31865124,3225009,-7972642,3936128,-5652273,-3050304 },
+ },
+ {
+ { 30625386,-4729400,-25555961,-12792866,-20484575,7695099,17097188,-16303496,-27999779,1803632 },
+ { -3553091,9865099,-5228566,4272701,-5673832,-16689700,14911344,12196514,-21405489,7047412 },
+ { 20093277,9920966,-11138194,-5343857,13161587,12044805,-32856851,4124601,-32343828,-10257566 },
+ },
+ {
+ { -20788824,14084654,-13531713,7842147,19119038,-13822605,4752377,-8714640,-21679658,2288038 },
+ { -26819236,-3283715,29965059,3039786,-14473765,2540457,29457502,14625692,-24819617,12570232 },
+ { -1063558,-11551823,16920318,12494842,1278292,-5869109,-21159943,-3498680,-11974704,4724943 },
+ },
+ {
+ { 17960970,-11775534,-4140968,-9702530,-8876562,-1410617,-12907383,-8659932,-29576300,1903856 },
+ { 23134274,-14279132,-10681997,-1611936,20684485,15770816,-12989750,3190296,26955097,14109738 },
+ { 15308788,5320727,-30113809,-14318877,22902008,7767164,29425325,-11277562,31960942,11934971 },
+ },
+ {
+ { -27395711,8435796,4109644,12222639,-24627868,14818669,20638173,4875028,10491392,1379718 },
+ { -13159415,9197841,3875503,-8936108,-1383712,-5879801,33518459,16176658,21432314,12180697 },
+ { -11787308,11500838,13787581,-13832590,-22430679,10140205,1465425,12689540,-10301319,-13872883 },
+ },
+},
+{
+ {
+ { 5414091,-15386041,-21007664,9643570,12834970,1186149,-2622916,-1342231,26128231,6032912 },
+ { -26337395,-13766162,32496025,-13653919,17847801,-12669156,3604025,8316894,-25875034,-10437358 },
+ { 3296484,6223048,24680646,-12246460,-23052020,5903205,-8862297,-4639164,12376617,3188849 },
+ },
+ {
+ { 29190488,-14659046,27549113,-1183516,3520066,-10697301,32049515,-7309113,-16109234,-9852307 },
+ { -14744486,-9309156,735818,-598978,-20407687,-5057904,25246078,-15795669,18640741,-960977 },
+ { -6928835,-16430795,10361374,5642961,4910474,12345252,-31638386,-494430,10530747,1053335 },
+ },
+ {
+ { -29265967,-14186805,-13538216,-12117373,-19457059,-10655384,-31462369,-2948985,24018831,15026644 },
+ { -22592535,-3145277,-2289276,5953843,-13440189,9425631,25310643,13003497,-2314791,-15145616 },
+ { -27419985,-603321,-8043984,-1669117,-26092265,13987819,-27297622,187899,-23166419,-2531735 },
+ },
+ {
+ { -21744398,-13810475,1844840,5021428,-10434399,-15911473,9716667,16266922,-5070217,726099 },
+ { 29370922,-6053998,7334071,-15342259,9385287,2247707,-13661962,-4839461,30007388,-15823341 },
+ { -936379,16086691,23751945,-543318,-1167538,-5189036,9137109,730663,9835848,4555336 },
+ },
+ {
+ { -23376435,1410446,-22253753,-12899614,30867635,15826977,17693930,544696,-11985298,12422646 },
+ { 31117226,-12215734,-13502838,6561947,-9876867,-12757670,-5118685,-4096706,29120153,13924425 },
+ { -17400879,-14233209,19675799,-2734756,-11006962,-5858820,-9383939,-11317700,7240931,-237388 },
+ },
+ {
+ { -31361739,-11346780,-15007447,-5856218,-22453340,-12152771,1222336,4389483,3293637,-15551743 },
+ { -16684801,-14444245,11038544,11054958,-13801175,-3338533,-24319580,7733547,12796905,-6335822 },
+ { -8759414,-10817836,-25418864,10783769,-30615557,-9746811,-28253339,3647836,3222231,-11160462 },
+ },
+ {
+ { 18606113,1693100,-25448386,-15170272,4112353,10045021,23603893,-2048234,-7550776,2484985 },
+ { 9255317,-3131197,-12156162,-1004256,13098013,-9214866,16377220,-2102812,-19802075,-3034702 },
+ { -22729289,7496160,-5742199,11329249,19991973,-3347502,-31718148,9936966,-30097688,-10618797 },
+ },
+ {
+ { 21878590,-5001297,4338336,13643897,-3036865,13160960,19708896,5415497,-7360503,-4109293 },
+ { 27736861,10103576,12500508,8502413,-3413016,-9633558,10436918,-1550276,-23659143,-8132100 },
+ { 19492550,-12104365,-29681976,-852630,-3208171,12403437,30066266,8367329,13243957,8709688 },
+ },
+},
+{
+ {
+ { 12015105,2801261,28198131,10151021,24818120,-4743133,-11194191,-5645734,5150968,7274186 },
+ { 2831366,-12492146,1478975,6122054,23825128,-12733586,31097299,6083058,31021603,-9793610 },
+ { -2529932,-2229646,445613,10720828,-13849527,-11505937,-23507731,16354465,15067285,-14147707 },
+ },
+ {
+ { 7840942,14037873,-33364863,15934016,-728213,-3642706,21403988,1057586,-19379462,-12403220 },
+ { 915865,-16469274,15608285,-8789130,-24357026,6060030,-17371319,8410997,-7220461,16527025 },
+ { 32922597,-556987,20336074,-16184568,10903705,-5384487,16957574,52992,23834301,6588044 },
+ },
+ {
+ { 32752030,11232950,3381995,-8714866,22652988,-10744103,17159699,16689107,-20314580,-1305992 },
+ { -4689649,9166776,-25710296,-10847306,11576752,12733943,7924251,-2752281,1976123,-7249027 },
+ { 21251222,16309901,-2983015,-6783122,30810597,12967303,156041,-3371252,12331345,-8237197 },
+ },
+ {
+ { 8651614,-4477032,-16085636,-4996994,13002507,2950805,29054427,-5106970,10008136,-4667901 },
+ { 31486080,15114593,-14261250,12951354,14369431,-7387845,16347321,-13662089,8684155,-10532952 },
+ { 19443825,11385320,24468943,-9659068,-23919258,2187569,-26263207,-6086921,31316348,14219878 },
+ },
+ {
+ { -28594490,1193785,32245219,11392485,31092169,15722801,27146014,6992409,29126555,9207390 },
+ { 32382935,1110093,18477781,11028262,-27411763,-7548111,-4980517,10843782,-7957600,-14435730 },
+ { 2814918,7836403,27519878,-7868156,-20894015,-11553689,-21494559,8550130,28346258,1994730 },
+ },
+ {
+ { -19578299,8085545,-14000519,-3948622,2785838,-16231307,-19516951,7174894,22628102,8115180 },
+ { -30405132,955511,-11133838,-15078069,-32447087,-13278079,-25651578,3317160,-9943017,930272 },
+ { -15303681,-6833769,28856490,1357446,23421993,1057177,24091212,-1388970,-22765376,-10650715 },
+ },
+ {
+ { -22751231,-5303997,-12907607,-12768866,-15811511,-7797053,-14839018,-16554220,-1867018,8398970 },
+ { -31969310,2106403,-4736360,1362501,12813763,16200670,22981545,-6291273,18009408,-15772772 },
+ { -17220923,-9545221,-27784654,14166835,29815394,7444469,29551787,-3727419,19288549,1325865 },
+ },
+ {
+ { 15100157,-15835752,-23923978,-1005098,-26450192,15509408,12376730,-3479146,33166107,-8042750 },
+ { 20909231,13023121,-9209752,16251778,-5778415,-8094914,12412151,10018715,2213263,-13878373 },
+ { 32529814,-11074689,30361439,-16689753,-9135940,1513226,22922121,6382134,-5766928,8371348 },
+ },
+},
+{
+ {
+ { 9923462,11271500,12616794,3544722,-29998368,-1721626,12891687,-8193132,-26442943,10486144 },
+ { -22597207,-7012665,8587003,-8257861,4084309,-12970062,361726,2610596,-23921530,-11455195 },
+ { 5408411,-1136691,-4969122,10561668,24145918,14240566,31319731,-4235541,19985175,-3436086 },
+ },
+ {
+ { -13994457,16616821,14549246,3341099,32155958,13648976,-17577068,8849297,65030,8370684 },
+ { -8320926,-12049626,31204563,5839400,-20627288,-1057277,-19442942,6922164,12743482,-9800518 },
+ { -2361371,12678785,28815050,4759974,-23893047,4884717,23783145,11038569,18800704,255233 },
+ },
+ {
+ { -5269658,-1773886,13957886,7990715,23132995,728773,13393847,9066957,19258688,-14753793 },
+ { -2936654,-10827535,-10432089,14516793,-3640786,4372541,-31934921,2209390,-1524053,2055794 },
+ { 580882,16705327,5468415,-2683018,-30926419,-14696000,-7203346,-8994389,-30021019,7394435 },
+ },
+ {
+ { 23838809,1822728,-15738443,15242727,8318092,-3733104,-21672180,-3492205,-4821741,14799921 },
+ { 13345610,9759151,3371034,-16137791,16353039,8577942,31129804,13496856,-9056018,7402518 },
+ { 2286874,-4435931,-20042458,-2008336,-13696227,5038122,11006906,-15760352,8205061,1607563 },
+ },
+ {
+ { 14414086,-8002132,3331830,-3208217,22249151,-5594188,18364661,-2906958,30019587,-9029278 },
+ { -27688051,1585953,-10775053,931069,-29120221,-11002319,-14410829,12029093,9944378,8024 },
+ { 4368715,-3709630,29874200,-15022983,-20230386,-11410704,-16114594,-999085,-8142388,5640030 },
+ },
+ {
+ { 10299610,13746483,11661824,16234854,7630238,5998374,9809887,-16694564,15219798,-14327783 },
+ { 27425505,-5719081,3055006,10660664,23458024,595578,-15398605,-1173195,-18342183,9742717 },
+ { 6744077,2427284,26042789,2720740,-847906,1118974,32324614,7406442,12420155,1994844 },
+ },
+ {
+ { 14012521,-5024720,-18384453,-9578469,-26485342,-3936439,-13033478,-10909803,24319929,-6446333 },
+ { 16412690,-4507367,10772641,15929391,-17068788,-4658621,10555945,-10484049,-30102368,-4739048 },
+ { 22397382,-7767684,-9293161,-12792868,17166287,-9755136,-27333065,6199366,21880021,-12250760 },
+ },
+ {
+ { -4283307,5368523,-31117018,8163389,-30323063,3209128,16557151,8890729,8840445,4957760 },
+ { -15447727,709327,-6919446,-10870178,-29777922,6522332,-21720181,12130072,-14796503,5005757 },
+ { -2114751,-14308128,23019042,15765735,-25269683,6002752,10183197,-13239326,-16395286,-2176112 },
+ },
+},
+{
+ {
+ { -19025756,1632005,13466291,-7995100,-23640451,16573537,-32013908,-3057104,22208662,2000468 },
+ { 3065073,-1412761,-25598674,-361432,-17683065,-5703415,-8164212,11248527,-3691214,-7414184 },
+ { 10379208,-6045554,8877319,1473647,-29291284,-12507580,16690915,2553332,-3132688,16400289 },
+ },
+ {
+ { 15716668,1254266,-18472690,7446274,-8448918,6344164,-22097271,-7285580,26894937,9132066 },
+ { 24158887,12938817,11085297,-8177598,-28063478,-4457083,-30576463,64452,-6817084,-2692882 },
+ { 13488534,7794716,22236231,5989356,25426474,-12578208,2350710,-3418511,-4688006,2364226 },
+ },
+ {
+ { 16335052,9132434,25640582,6678888,1725628,8517937,-11807024,-11697457,15445875,-7798101 },
+ { 29004207,-7867081,28661402,-640412,-12794003,-7943086,31863255,-4135540,-278050,-15759279 },
+ { -6122061,-14866665,-28614905,14569919,-10857999,-3591829,10343412,-6976290,-29828287,-10815811 },
+ },
+ {
+ { 27081650,3463984,14099042,-4517604,1616303,-6205604,29542636,15372179,17293797,960709 },
+ { 20263915,11434237,-5765435,11236810,13505955,-10857102,-16111345,6493122,-19384511,7639714 },
+ { -2830798,-14839232,25403038,-8215196,-8317012,-16173699,18006287,-16043750,29994677,-15808121 },
+ },
+ {
+ { 9769828,5202651,-24157398,-13631392,-28051003,-11561624,-24613141,-13860782,-31184575,709464 },
+ { 12286395,13076066,-21775189,-1176622,-25003198,4057652,-32018128,-8890874,16102007,13205847 },
+ { 13733362,5599946,10557076,3195751,-5557991,8536970,-25540170,8525972,10151379,10394400 },
+ },
+ {
+ { 4024660,-16137551,22436262,12276534,-9099015,-2686099,19698229,11743039,-33302334,8934414 },
+ { -15879800,-4525240,-8580747,-2934061,14634845,-698278,-9449077,3137094,-11536886,11721158 },
+ { 17555939,-5013938,8268606,2331751,-22738815,9761013,9319229,8835153,-9205489,-1280045 },
+ },
+ {
+ { -461409,-7830014,20614118,16688288,-7514766,-4807119,22300304,505429,6108462,-6183415 },
+ { -5070281,12367917,-30663534,3234473,32617080,-8422642,29880583,-13483331,-26898490,-7867459 },
+ { -31975283,5726539,26934134,10237677,-3173717,-605053,24199304,3795095,7592688,-14992079 },
+ },
+ {
+ { 21594432,-14964228,17466408,-4077222,32537084,2739898,6407723,12018833,-28256052,4298412 },
+ { -20650503,-11961496,-27236275,570498,3767144,-1717540,13891942,-1569194,13717174,10805743 },
+ { -14676630,-15644296,15287174,11927123,24177847,-8175568,-796431,14860609,-26938930,-5863836 },
+ },
+},
+{
+ {
+ { 12962541,5311799,-10060768,11658280,18855286,-7954201,13286263,-12808704,-4381056,9882022 },
+ { 18512079,11319350,-20123124,15090309,18818594,5271736,-22727904,3666879,-23967430,-3299429 },
+ { -6789020,-3146043,16192429,13241070,15898607,-14206114,-10084880,-6661110,-2403099,5276065 },
+ },
+ {
+ { 30169808,-5317648,26306206,-11750859,27814964,7069267,7152851,3684982,1449224,13082861 },
+ { 10342826,3098505,2119311,193222,25702612,12233820,23697382,15056736,-21016438,-8202000 },
+ { -33150110,3261608,22745853,7948688,19370557,-15177665,-26171976,6482814,-10300080,-11060101 },
+ },
+ {
+ { 32869458,-5408545,25609743,15678670,-10687769,-15471071,26112421,2521008,-22664288,6904815 },
+ { 29506923,4457497,3377935,-9796444,-30510046,12935080,1561737,3841096,-29003639,-6657642 },
+ { 10340844,-6630377,-18656632,-2278430,12621151,-13339055,30878497,-11824370,-25584551,5181966 },
+ },
+ {
+ { 25940115,-12658025,17324188,-10307374,-8671468,15029094,24396252,-16450922,-2322852,-12388574 },
+ { -21765684,9916823,-1300409,4079498,-1028346,11909559,1782390,12641087,20603771,-6561742 },
+ { -18882287,-11673380,24849422,11501709,13161720,-4768874,1925523,11914390,4662781,7820689 },
+ },
+ {
+ { 12241050,-425982,8132691,9393934,32846760,-1599620,29749456,12172924,16136752,15264020 },
+ { -10349955,-14680563,-8211979,2330220,-17662549,-14545780,10658213,6671822,19012087,3772772 },
+ { 3753511,-3421066,10617074,2028709,14841030,-6721664,28718732,-15762884,20527771,12988982 },
+ },
+ {
+ { -14822485,-5797269,-3707987,12689773,-898983,-10914866,-24183046,-10564943,3299665,-12424953 },
+ { -16777703,-15253301,-9642417,4978983,3308785,8755439,6943197,6461331,-25583147,8991218 },
+ { -17226263,1816362,-1673288,-6086439,31783888,-8175991,-32948145,7417950,-30242287,1507265 },
+ },
+ {
+ { 29692663,6829891,-10498800,4334896,20945975,-11906496,-28887608,8209391,14606362,-10647073 },
+ { -3481570,8707081,32188102,5672294,22096700,1711240,-33020695,9761487,4170404,-2085325 },
+ { -11587470,14855945,-4127778,-1531857,-26649089,15084046,22186522,16002000,-14276837,-8400798 },
+ },
+ {
+ { -4811456,13761029,-31703877,-2483919,-3312471,7869047,-7113572,-9620092,13240845,10965870 },
+ { -7742563,-8256762,-14768334,-13656260,-23232383,12387166,4498947,14147411,29514390,4302863 },
+ { -13413405,-12407859,20757302,-13801832,14785143,8976368,-5061276,-2144373,17846988,-13971927 },
+ },
+},
+{
+ {
+ { -2244452,-754728,-4597030,-1066309,-6247172,1455299,-21647728,-9214789,-5222701,12650267 },
+ { -9906797,-16070310,21134160,12198166,-27064575,708126,387813,13770293,-19134326,10958663 },
+ { 22470984,12369526,23446014,-5441109,-21520802,-9698723,-11772496,-11574455,-25083830,4271862 },
+ },
+ {
+ { -25169565,-10053642,-19909332,15361595,-5984358,2159192,75375,-4278529,-32526221,8469673 },
+ { 15854970,4148314,-8893890,7259002,11666551,13824734,-30531198,2697372,24154791,-9460943 },
+ { 15446137,-15806644,29759747,14019369,30811221,-9610191,-31582008,12840104,24913809,9815020 },
+ },
+ {
+ { -4709286,-5614269,-31841498,-12288893,-14443537,10799414,-9103676,13438769,18735128,9466238 },
+ { 11933045,9281483,5081055,-5183824,-2628162,-4905629,-7727821,-10896103,-22728655,16199064 },
+ { 14576810,379472,-26786533,-8317236,-29426508,-10812974,-102766,1876699,30801119,2164795 },
+ },
+ {
+ { 15995086,3199873,13672555,13712240,-19378835,-4647646,-13081610,-15496269,-13492807,1268052 },
+ { -10290614,-3659039,-3286592,10948818,23037027,3794475,-3470338,-12600221,-17055369,3565904 },
+ { 29210088,-9419337,-5919792,-4952785,10834811,-13327726,-16512102,-10820713,-27162222,-14030531 },
+ },
+ {
+ { -13161890,15508588,16663704,-8156150,-28349942,9019123,-29183421,-3769423,2244111,-14001979 },
+ { -5152875,-3800936,-9306475,-6071583,16243069,14684434,-25673088,-16180800,13491506,4641841 },
+ { 10813417,643330,-19188515,-728916,30292062,-16600078,27548447,-7721242,14476989,-12767431 },
+ },
+ {
+ { 10292079,9984945,6481436,8279905,-7251514,7032743,27282937,-1644259,-27912810,12651324 },
+ { -31185513,-813383,22271204,11835308,10201545,15351028,17099662,3988035,21721536,-3148940 },
+ { 10202177,-6545839,-31373232,-9574638,-32150642,-8119683,-12906320,3852694,13216206,14842320 },
+ },
+ {
+ { -15815640,-10601066,-6538952,-7258995,-6984659,-6581778,-31500847,13765824,-27434397,9900184 },
+ { 14465505,-13833331,-32133984,-14738873,-27443187,12990492,33046193,15796406,-7051866,-8040114 },
+ { 30924417,-8279620,6359016,-12816335,16508377,9071735,-25488601,15413635,9524356,-7018878 },
+ },
+ {
+ { 12274201,-13175547,32627641,-1785326,6736625,13267305,5237659,-5109483,15663516,4035784 },
+ { -2951309,8903985,17349946,601635,-16432815,-4612556,-13732739,-15889334,-22258478,4659091 },
+ { -16916263,-4952973,-30393711,-15158821,20774812,15897498,5736189,15026997,-2178256,-13455585 },
+ },
+},
+{
+ {
+ { -8858980,-2219056,28571666,-10155518,-474467,-10105698,-3801496,278095,23440562,-290208 },
+ { 10226241,-5928702,15139956,120818,-14867693,5218603,32937275,11551483,-16571960,-7442864 },
+ { 17932739,-12437276,-24039557,10749060,11316803,7535897,22503767,5561594,-3646624,3898661 },
+ },
+ {
+ { 7749907,-969567,-16339731,-16464,-25018111,15122143,-1573531,7152530,21831162,1245233 },
+ { 26958459,-14658026,4314586,8346991,-5677764,11960072,-32589295,-620035,-30402091,-16716212 },
+ { -12165896,9166947,33491384,13673479,29787085,13096535,6280834,14587357,-22338025,13987525 },
+ },
+ {
+ { -24349909,7778775,21116000,15572597,-4833266,-5357778,-4300898,-5124639,-7469781,-2858068 },
+ { 9681908,-6737123,-31951644,13591838,-6883821,386950,31622781,6439245,-14581012,4091397 },
+ { -8426427,1470727,-28109679,-1596990,3978627,-5123623,-19622683,12092163,29077877,-14741988 },
+ },
+ {
+ { 5269168,-6859726,-13230211,-8020715,25932563,1763552,-5606110,-5505881,-20017847,2357889 },
+ { 32264008,-15407652,-5387735,-1160093,-2091322,-3946900,23104804,-12869908,5727338,189038 },
+ { 14609123,-8954470,-6000566,-16622781,-14577387,-7743898,-26745169,10942115,-25888931,-14884697 },
+ },
+ {
+ { 20513500,5557931,-15604613,7829531,26413943,-2019404,-21378968,7471781,13913677,-5137875 },
+ { -25574376,11967826,29233242,12948236,-6754465,4713227,-8940970,14059180,12878652,8511905 },
+ { -25656801,3393631,-2955415,-7075526,-2250709,9366908,-30223418,6812974,5568676,-3127656 },
+ },
+ {
+ { 11630004,12144454,2116339,13606037,27378885,15676917,-17408753,-13504373,-14395196,8070818 },
+ { 27117696,-10007378,-31282771,-5570088,1127282,12772488,-29845906,10483306,-11552749,-1028714 },
+ { 10637467,-5688064,5674781,1072708,-26343588,-6982302,-1683975,9177853,-27493162,15431203 },
+ },
+ {
+ { 20525145,10892566,-12742472,12779443,-29493034,16150075,-28240519,14943142,-15056790,-7935931 },
+ { -30024462,5626926,-551567,-9981087,753598,11981191,25244767,-3239766,-3356550,9594024 },
+ { -23752644,2636870,-5163910,-10103818,585134,7877383,11345683,-6492290,13352335,-10977084 },
+ },
+ {
+ { -1931799,-5407458,3304649,-12884869,17015806,-4877091,-29783850,-7752482,-13215537,-319204 },
+ { 20239939,6607058,6203985,3483793,-18386976,-779229,-20723742,15077870,-22750759,14523817 },
+ { 27406042,-6041657,27423596,-4497394,4996214,10002360,-28842031,-4545494,-30172742,-4805667 },
+ },
+},
+{
+ {
+ { 11374242,12660715,17861383,-12540833,10935568,1099227,-13886076,-9091740,-27727044,11358504 },
+ { -12730809,10311867,1510375,10778093,-2119455,-9145702,32676003,11149336,-26123651,4985768 },
+ { -19096303,341147,-6197485,-239033,15756973,-8796662,-983043,13794114,-19414307,-15621255 },
+ },
+ {
+ { 6490081,11940286,25495923,-7726360,8668373,-8751316,3367603,6970005,-1691065,-9004790 },
+ { 1656497,13457317,15370807,6364910,13605745,8362338,-19174622,-5475723,-16796596,-5031438 },
+ { -22273315,-13524424,-64685,-4334223,-18605636,-10921968,-20571065,-7007978,-99853,-10237333 },
+ },
+ {
+ { 17747465,10039260,19368299,-4050591,-20630635,-16041286,31992683,-15857976,-29260363,-5511971 },
+ { 31932027,-4986141,-19612382,16366580,22023614,88450,11371999,-3744247,4882242,-10626905 },
+ { 29796507,37186,19818052,10115756,-11829032,3352736,18551198,3272828,-5190932,-4162409 },
+ },
+ {
+ { 12501286,4044383,-8612957,-13392385,-32430052,5136599,-19230378,-3529697,330070,-3659409 },
+ { 6384877,2899513,17807477,7663917,-2358888,12363165,25366522,-8573892,-271295,12071499 },
+ { -8365515,-4042521,25133448,-4517355,-6211027,2265927,-32769618,1936675,-5159697,3829363 },
+ },
+ {
+ { 28425966,-5835433,-577090,-4697198,-14217555,6870930,7921550,-6567787,26333140,14267664 },
+ { -11067219,11871231,27385719,-10559544,-4585914,-11189312,10004786,-8709488,-21761224,8930324 },
+ { -21197785,-16396035,25654216,-1725397,12282012,11008919,1541940,4757911,-26491501,-16408940 },
+ },
+ {
+ { 13537262,-7759490,-20604840,10961927,-5922820,-13218065,-13156584,6217254,-15943699,13814990 },
+ { -17422573,15157790,18705543,29619,24409717,-260476,27361681,9257833,-1956526,-1776914 },
+ { -25045300,-10191966,15366585,15166509,-13105086,8423556,-29171540,12361135,-18685978,4578290 },
+ },
+ {
+ { 24579768,3711570,1342322,-11180126,-27005135,14124956,-22544529,14074919,21964432,8235257 },
+ { -6528613,-2411497,9442966,-5925588,12025640,-1487420,-2981514,-1669206,13006806,2355433 },
+ { -16304899,-13605259,-6632427,-5142349,16974359,-10911083,27202044,1719366,1141648,-12796236 },
+ },
+ {
+ { -12863944,-13219986,-8318266,-11018091,-6810145,-4843894,13475066,-3133972,32674895,13715045 },
+ { 11423335,-5468059,32344216,8962751,24989809,9241752,-13265253,16086212,-28740881,-15642093 },
+ { -1409668,12530728,-6368726,10847387,19531186,-14132160,-11709148,7791794,-27245943,4383347 },
+ },
+},
+{
+ {
+ { -28970898,5271447,-1266009,-9736989,-12455236,16732599,-4862407,-4906449,27193557,6245191 },
+ { -15193956,5362278,-1783893,2695834,4960227,12840725,23061898,3260492,22510453,8577507 },
+ { -12632451,11257346,-32692994,13548177,-721004,10879011,31168030,13952092,-29571492,-3635906 },
+ },
+ {
+ { 3877321,-9572739,32416692,5405324,-11004407,-13656635,3759769,11935320,5611860,8164018 },
+ { -16275802,14667797,15906460,12155291,-22111149,-9039718,32003002,-8832289,5773085,-8422109 },
+ { -23788118,-8254300,1950875,8937633,18686727,16459170,-905725,12376320,31632953,190926 },
+ },
+ {
+ { -24593607,-16138885,-8423991,13378746,14162407,6901328,-8288749,4508564,-25341555,-3627528 },
+ { 8884438,-5884009,6023974,10104341,-6881569,-4941533,18722941,-14786005,-1672488,827625 },
+ { -32720583,-16289296,-32503547,7101210,13354605,2659080,-1800575,-14108036,-24878478,1541286 },
+ },
+ {
+ { 2901347,-1117687,3880376,-10059388,-17620940,-3612781,-21802117,-3567481,20456845,-1885033 },
+ { 27019610,12299467,-13658288,-1603234,-12861660,-4861471,-19540150,-5016058,29439641,15138866 },
+ { 21536104,-6626420,-32447818,-10690208,-22408077,5175814,-5420040,-16361163,7779328,109896 },
+ },
+ {
+ { 30279744,14648750,-8044871,6425558,13639621,-743509,28698390,12180118,23177719,-554075 },
+ { 26572847,3405927,-31701700,12890905,-19265668,5335866,-6493768,2378492,4439158,-13279347 },
+ { -22716706,3489070,-9225266,-332753,18875722,-1140095,14819434,-12731527,-17717757,-5461437 },
+ },
+ {
+ { -5056483,16566551,15953661,3767752,-10436499,15627060,-820954,2177225,8550082,-15114165 },
+ { -18473302,16596775,-381660,15663611,22860960,15585581,-27844109,-3582739,-23260460,-8428588 },
+ { -32480551,15707275,-8205912,-5652081,29464558,2713815,-22725137,15860482,-21902570,1494193 },
+ },
+ {
+ { -19562091,-14087393,-25583872,-9299552,13127842,759709,21923482,16529112,8742704,12967017 },
+ { -28464899,1553205,32536856,-10473729,-24691605,-406174,-8914625,-2933896,-29903758,15553883 },
+ { 21877909,3230008,9881174,10539357,-4797115,2841332,11543572,14513274,19375923,-12647961 },
+ },
+ {
+ { 8832269,-14495485,13253511,5137575,5037871,4078777,24880818,-6222716,2862653,9455043 },
+ { 29306751,5123106,20245049,-14149889,9592566,8447059,-2077124,-2990080,15511449,4789663 },
+ { -20679756,7004547,8824831,-9434977,-4045704,-3750736,-5754762,108893,23513200,16652362 },
+ },
+},
+{
+ {
+ { -33256173,4144782,-4476029,-6579123,10770039,-7155542,-6650416,-12936300,-18319198,10212860 },
+ { 2756081,8598110,7383731,-6859892,22312759,-1105012,21179801,2600940,-9988298,-12506466 },
+ { -24645692,13317462,-30449259,-15653928,21365574,-10869657,11344424,864440,-2499677,-16710063 },
+ },
+ {
+ { -26432803,6148329,-17184412,-14474154,18782929,-275997,-22561534,211300,2719757,4940997 },
+ { -1323882,3911313,-6948744,14759765,-30027150,7851207,21690126,8518463,26699843,5276295 },
+ { -13149873,-6429067,9396249,365013,24703301,-10488939,1321586,149635,-15452774,7159369 },
+ },
+ {
+ { 9987780,-3404759,17507962,9505530,9731535,-2165514,22356009,8312176,22477218,-8403385 },
+ { 18155857,-16504990,19744716,9006923,15154154,-10538976,24256460,-4864995,-22548173,9334109 },
+ { 2986088,-4911893,10776628,-3473844,10620590,-7083203,-21413845,14253545,-22587149,536906 },
+ },
+ {
+ { 4377756,8115836,24567078,15495314,11625074,13064599,7390551,10589625,10838060,-15420424 },
+ { -19342404,867880,9277171,-3218459,-14431572,-1986443,19295826,-15796950,6378260,699185 },
+ { 7895026,4057113,-7081772,-13077756,-17886831,-323126,-716039,15693155,-5045064,-13373962 },
+ },
+ {
+ { -7737563,-5869402,-14566319,-7406919,11385654,13201616,31730678,-10962840,-3918636,-9669325 },
+ { 10188286,-15770834,-7336361,13427543,22223443,14896287,30743455,7116568,-21786507,5427593 },
+ { 696102,13206899,27047647,-10632082,15285305,-9853179,10798490,-4578720,19236243,12477404 },
+ },
+ {
+ { -11229439,11243796,-17054270,-8040865,-788228,-8167967,-3897669,11180504,-23169516,7733644 },
+ { 17800790,-14036179,-27000429,-11766671,23887827,3149671,23466177,-10538171,10322027,15313801 },
+ { 26246234,11968874,32263343,-5468728,6830755,-13323031,-15794704,-101982,-24449242,10890804 },
+ },
+ {
+ { -31365647,10271363,-12660625,-6267268,16690207,-13062544,-14982212,16484931,25180797,-5334884 },
+ { -586574,10376444,-32586414,-11286356,19801893,10997610,2276632,9482883,316878,13820577 },
+ { -9882808,-4510367,-2115506,16457136,-11100081,11674996,30756178,-7515054,30696930,-3712849 },
+ },
+ {
+ { 32988917,-9603412,12499366,7910787,-10617257,-11931514,-7342816,-9985397,-32349517,7392473 },
+ { -8855661,15927861,9866406,-3649411,-2396914,-16655781,-30409476,-9134995,25112947,-2926644 },
+ { -2504044,-436966,25621774,-5678772,15085042,-5479877,-24884878,-13526194,5537438,-13914319 },
+ },
+},
+{
+ {
+ { -11225584,2320285,-9584280,10149187,-33444663,5808648,-14876251,-1729667,31234590,6090599 },
+ { -9633316,116426,26083934,2897444,-6364437,-2688086,609721,15878753,-6970405,-9034768 },
+ { -27757857,247744,-15194774,-9002551,23288161,-10011936,-23869595,6503646,20650474,1804084 },
+ },
+ {
+ { -27589786,15456424,8972517,8469608,15640622,4439847,3121995,-10329713,27842616,-202328 },
+ { -15306973,2839644,22530074,10026331,4602058,5048462,28248656,5031932,-11375082,12714369 },
+ { 20807691,-7270825,29286141,11421711,-27876523,-13868230,-21227475,1035546,-19733229,12796920 },
+ },
+ {
+ { 12076899,-14301286,-8785001,-11848922,-25012791,16400684,-17591495,-12899438,3480665,-15182815 },
+ { -32361549,5457597,28548107,7833186,7303070,-11953545,-24363064,-15921875,-33374054,2771025 },
+ { -21389266,421932,26597266,6860826,22486084,-6737172,-17137485,-4210226,-24552282,15673397 },
+ },
+ {
+ { -20184622,2338216,19788685,-9620956,-4001265,-8740893,-20271184,4733254,3727144,-12934448 },
+ { 6120119,814863,-11794402,-622716,6812205,-15747771,2019594,7975683,31123697,-10958981 },
+ { 30069250,-11435332,30434654,2958439,18399564,-976289,12296869,9204260,-16432438,9648165 },
+ },
+ {
+ { 32705432,-1550977,30705658,7451065,-11805606,9631813,3305266,5248604,-26008332,-11377501 },
+ { 17219865,2375039,-31570947,-5575615,-19459679,9219903,294711,15298639,2662509,-16297073 },
+ { -1172927,-7558695,-4366770,-4287744,-21346413,-8434326,32087529,-1222777,32247248,-14389861 },
+ },
+ {
+ { 14312628,1221556,17395390,-8700143,-4945741,-8684635,-28197744,-9637817,-16027623,-13378845 },
+ { -1428825,-9678990,-9235681,6549687,-7383069,-468664,23046502,9803137,17597934,2346211 },
+ { 18510800,15337574,26171504,981392,-22241552,7827556,-23491134,-11323352,3059833,-11782870 },
+ },
+ {
+ { 10141598,6082907,17829293,-1947643,9830092,13613136,-25556636,-5544586,-33502212,3592096 },
+ { 33114168,-15889352,-26525686,-13343397,33076705,8716171,1151462,1521897,-982665,-6837803 },
+ { -32939165,-4255815,23947181,-324178,-33072974,-12305637,-16637686,3891704,26353178,693168 },
+ },
+ {
+ { 30374239,1595580,-16884039,13186931,4600344,406904,9585294,-400668,31375464,14369965 },
+ { -14370654,-7772529,1510301,6434173,-18784789,-6262728,32732230,-13108839,17901441,16011505 },
+ { 18171223,-11934626,-12500402,15197122,-11038147,-15230035,-19172240,-16046376,8764035,12309598 },
+ },
+},
+{
+ {
+ { 5975908,-5243188,-19459362,-9681747,-11541277,14015782,-23665757,1228319,17544096,-10593782 },
+ { 5811932,-1715293,3442887,-2269310,-18367348,-8359541,-18044043,-15410127,-5565381,12348900 },
+ { -31399660,11407555,25755363,6891399,-3256938,14872274,-24849353,8141295,-10632534,-585479 },
+ },
+ {
+ { -12675304,694026,-5076145,13300344,14015258,-14451394,-9698672,-11329050,30944593,1130208 },
+ { 8247766,-6710942,-26562381,-7709309,-14401939,-14648910,4652152,2488540,23550156,-271232 },
+ { 17294316,-3788438,7026748,15626851,22990044,113481,2267737,-5908146,-408818,-137719 },
+ },
+ {
+ { 16091085,-16253926,18599252,7340678,2137637,-1221657,-3364161,14550936,3260525,-7166271 },
+ { -4910104,-13332887,18550887,10864893,-16459325,-7291596,-23028869,-13204905,-12748722,2701326 },
+ { -8574695,16099415,4629974,-16340524,-20786213,-6005432,-10018363,9276971,11329923,1862132 },
+ },
+ {
+ { 14763076,-15903608,-30918270,3689867,3511892,10313526,-21951088,12219231,-9037963,-940300 },
+ { 8894987,-3446094,6150753,3013931,301220,15693451,-31981216,-2909717,-15438168,11595570 },
+ { 15214962,3537601,-26238722,-14058872,4418657,-15230761,13947276,10730794,-13489462,-4363670 },
+ },
+ {
+ { -2538306,7682793,32759013,263109,-29984731,-7955452,-22332124,-10188635,977108,699994 },
+ { -12466472,4195084,-9211532,550904,-15565337,12917920,19118110,-439841,-30534533,-14337913 },
+ { 31788461,-14507657,4799989,7372237,8808585,-14747943,9408237,-10051775,12493932,-5409317 },
+ },
+ {
+ { -25680606,5260744,-19235809,-6284470,-3695942,16566087,27218280,2607121,29375955,6024730 },
+ { 842132,-2794693,-4763381,-8722815,26332018,-12405641,11831880,6985184,-9940361,2854096 },
+ { -4847262,-7969331,2516242,-5847713,9695691,-7221186,16512645,960770,12121869,16648078 },
+ },
+ {
+ { -15218652,14667096,-13336229,2013717,30598287,-464137,-31504922,-7882064,20237806,2838411 },
+ { -19288047,4453152,15298546,-16178388,22115043,-15972604,12544294,-13470457,1068881,-12499905 },
+ { -9558883,-16518835,33238498,13506958,30505848,-1114596,-8486907,-2630053,12521378,4845654 },
+ },
+ {
+ { -28198521,10744108,-2958380,10199664,7759311,-13088600,3409348,-873400,-6482306,-12885870 },
+ { -23561822,6230156,-20382013,10655314,-24040585,-11621172,10477734,-1240216,-3113227,13974498 },
+ { 12966261,15550616,-32038948,-1615346,21025980,-629444,5642325,7188737,18895762,12629579 },
+ },
+},
+{
+ {
+ { 14741879,-14946887,22177208,-11721237,1279741,8058600,11758140,789443,32195181,3895677 },
+ { 10758205,15755439,-4509950,9243698,-4879422,6879879,-2204575,-3566119,-8982069,4429647 },
+ { -2453894,15725973,-20436342,-10410672,-5803908,-11040220,-7135870,-11642895,18047436,-15281743 },
+ },
+ {
+ { -25173001,-11307165,29759956,11776784,-22262383,-15820455,10993114,-12850837,-17620701,-9408468 },
+ { 21987233,700364,-24505048,14972008,-7774265,-5718395,32155026,2581431,-29958985,8773375 },
+ { -25568350,454463,-13211935,16126715,25240068,8594567,20656846,12017935,-7874389,-13920155 },
+ },
+ {
+ { 6028182,6263078,-31011806,-11301710,-818919,2461772,-31841174,-5468042,-1721788,-2776725 },
+ { -12278994,16624277,987579,-5922598,32908203,1248608,7719845,-4166698,28408820,6816612 },
+ { -10358094,-8237829,19549651,-12169222,22082623,16147817,20613181,13982702,-10339570,5067943 },
+ },
+ {
+ { -30505967,-3821767,12074681,13582412,-19877972,2443951,-19719286,12746132,5331210,-10105944 },
+ { 30528811,3601899,-1957090,4619785,-27361822,-15436388,24180793,-12570394,27679908,-1648928 },
+ { 9402404,-13957065,32834043,10838634,-26580150,-13237195,26653274,-8685565,22611444,-12715406 },
+ },
+ {
+ { 22190590,1118029,22736441,15130463,-30460692,-5991321,19189625,-4648942,4854859,6622139 },
+ { -8310738,-2953450,-8262579,-3388049,-10401731,-271929,13424426,-3567227,26404409,13001963 },
+ { -31241838,-15415700,-2994250,8939346,11562230,-12840670,-26064365,-11621720,-15405155,11020693 },
+ },
+ {
+ { 1866042,-7949489,-7898649,-10301010,12483315,13477547,3175636,-12424163,28761762,1406734 },
+ { -448555,-1777666,13018551,3194501,-9580420,-11161737,24760585,-4347088,25577411,-13378680 },
+ { -24290378,4759345,-690653,-1852816,2066747,10693769,-29595790,9884936,-9368926,4745410 },
+ },
+ {
+ { -9141284,6049714,-19531061,-4341411,-31260798,9944276,-15462008,-11311852,10931924,-11931931 },
+ { -16561513,14112680,-8012645,4817318,-8040464,-11414606,-22853429,10856641,-20470770,13434654 },
+ { 22759489,-10073434,-16766264,-1871422,13637442,-10168091,1765144,-12654326,28445307,-5364710 },
+ },
+ {
+ { 29875063,12493613,2795536,-3786330,1710620,15181182,-10195717,-8788675,9074234,1167180 },
+ { -26205683,11014233,-9842651,-2635485,-26908120,7532294,-18716888,-9535498,3843903,9367684 },
+ { -10969595,-6403711,9591134,9582310,11349256,108879,16235123,8601684,-139197,4242895 },
+ },
+},
+{
+ {
+ { 22092954,-13191123,-2042793,-11968512,32186753,-11517388,-6574341,2470660,-27417366,16625501 },
+ { -11057722,3042016,13770083,-9257922,584236,-544855,-7770857,2602725,-27351616,14247413 },
+ { 6314175,-10264892,-32772502,15957557,-10157730,168750,-8618807,14290061,27108877,-1180880 },
+ },
+ {
+ { -8586597,-7170966,13241782,10960156,-32991015,-13794596,33547976,-11058889,-27148451,981874 },
+ { 22833440,9293594,-32649448,-13618667,-9136966,14756819,-22928859,-13970780,-10479804,-16197962 },
+ { -7768587,3326786,-28111797,10783824,19178761,14905060,22680049,13906969,-15933690,3797899 },
+ },
+ {
+ { 21721356,-4212746,-12206123,9310182,-3882239,-13653110,23740224,-2709232,20491983,-8042152 },
+ { 9209270,-15135055,-13256557,-6167798,-731016,15289673,25947805,15286587,30997318,-6703063 },
+ { 7392032,16618386,23946583,-8039892,-13265164,-1533858,-14197445,-2321576,17649998,-250080 },
+ },
+ {
+ { -9301088,-14193827,30609526,-3049543,-25175069,-1283752,-15241566,-9525724,-2233253,7662146 },
+ { -17558673,1763594,-33114336,15908610,-30040870,-12174295,7335080,-8472199,-3174674,3440183 },
+ { -19889700,-5977008,-24111293,-9688870,10799743,-16571957,40450,-4431835,4862400,1133 },
+ },
+ {
+ { -32856209,-7873957,-5422389,14860950,-16319031,7956142,7258061,311861,-30594991,-7379421 },
+ { -3773428,-1565936,28985340,7499440,24445838,9325937,29727763,16527196,18278453,15405622 },
+ { -4381906,8508652,-19898366,-3674424,-5984453,15149970,-13313598,843523,-21875062,13626197 },
+ },
+ {
+ { 2281448,-13487055,-10915418,-2609910,1879358,16164207,-10783882,3953792,13340839,15928663 },
+ { 31727126,-7179855,-18437503,-8283652,2875793,-16390330,-25269894,-7014826,-23452306,5964753 },
+ { 4100420,-5959452,-17179337,6017714,-18705837,12227141,-26684835,11344144,2538215,-7570755 },
+ },
+ {
+ { -9433605,6123113,11159803,-2156608,30016280,14966241,-20474983,1485421,-629256,-15958862 },
+ { -26804558,4260919,11851389,9658551,-32017107,16367492,-20205425,-13191288,11659922,-11115118 },
+ { 26180396,10015009,-30844224,-8581293,5418197,9480663,2231568,-10170080,33100372,-1306171 },
+ },
+ {
+ { 15121113,-5201871,-10389905,15427821,-27509937,-15992507,21670947,4486675,-5931810,-14466380 },
+ { 16166486,-9483733,-11104130,6023908,-31926798,-1364923,2340060,-16254968,-10735770,-10039824 },
+ { 28042865,-3557089,-12126526,12259706,-3717498,-6945899,6766453,-8689599,18036436,5803270 },
+ },
+},
+{
+ {
+ { -817581,6763912,11803561,1585585,10958447,-2671165,23855391,4598332,-6159431,-14117438 },
+ { -31031306,-14256194,17332029,-2383520,31312682,-5967183,696309,50292,-20095739,11763584 },
+ { -594563,-2514283,-32234153,12643980,12650761,14811489,665117,-12613632,-19773211,-10713562 },
+ },
+ {
+ { 30464590,-11262872,-4127476,-12734478,19835327,-7105613,-24396175,2075773,-17020157,992471 },
+ { 18357185,-6994433,7766382,16342475,-29324918,411174,14578841,8080033,-11574335,-10601610 },
+ { 19598397,10334610,12555054,2555664,18821899,-10339780,21873263,16014234,26224780,16452269 },
+ },
+ {
+ { -30223925,5145196,5944548,16385966,3976735,2009897,-11377804,-7618186,-20533829,3698650 },
+ { 14187449,3448569,-10636236,-10810935,-22663880,-3433596,7268410,-10890444,27394301,12015369 },
+ { 19695761,16087646,28032085,12999827,6817792,11427614,20244189,-1312777,-13259127,-3402461 },
+ },
+ {
+ { 30860103,12735208,-1888245,-4699734,-16974906,2256940,-8166013,12298312,-8550524,-10393462 },
+ { -5719826,-11245325,-1910649,15569035,26642876,-7587760,-5789354,-15118654,-4976164,12651793 },
+ { -2848395,9953421,11531313,-5282879,26895123,-12697089,-13118820,-16517902,9768698,-2533218 },
+ },
+ {
+ { -24719459,1894651,-287698,-4704085,15348719,-8156530,32767513,12765450,4940095,10678226 },
+ { 18860224,15980149,-18987240,-1562570,-26233012,-11071856,-7843882,13944024,-24372348,16582019 },
+ { -15504260,4970268,-29893044,4175593,-20993212,-2199756,-11704054,15444560,-11003761,7989037 },
+ },
+ {
+ { 31490452,5568061,-2412803,2182383,-32336847,4531686,-32078269,6200206,-19686113,-14800171 },
+ { -17308668,-15879940,-31522777,-2831,-32887382,16375549,8680158,-16371713,28550068,-6857132 },
+ { -28126887,-5688091,16837845,-1820458,-6850681,12700016,-30039981,4364038,1155602,5988841 },
+ },
+ {
+ { 21890435,-13272907,-12624011,12154349,-7831873,15300496,23148983,-4470481,24618407,8283181 },
+ { -33136107,-10512751,9975416,6841041,-31559793,16356536,3070187,-7025928,1466169,10740210 },
+ { -1509399,-15488185,-13503385,-10655916,32799044,909394,-13938903,-5779719,-32164649,-15327040 },
+ },
+ {
+ { 3960823,-14267803,-28026090,-15918051,-19404858,13146868,15567327,951507,-3260321,-573935 },
+ { 24740841,5052253,-30094131,8961361,25877428,6165135,-24368180,14397372,-7380369,-6144105 },
+ { -28888365,3510803,-28103278,-1158478,-11238128,-10631454,-15441463,-14453128,-1625486,-6494814 },
+ },
+},
+{
+ {
+ { 793299,-9230478,8836302,-6235707,-27360908,-2369593,33152843,-4885251,-9906200,-621852 },
+ { 5666233,525582,20782575,-8038419,-24538499,14657740,16099374,1468826,-6171428,-15186581 },
+ { -4859255,-3779343,-2917758,-6748019,7778750,11688288,-30404353,-9871238,-1558923,-9863646 },
+ },
+ {
+ { 10896332,-7719704,824275,472601,-19460308,3009587,25248958,14783338,-30581476,-15757844 },
+ { 10566929,12612572,-31944212,11118703,-12633376,12362879,21752402,8822496,24003793,14264025 },
+ { 27713862,-7355973,-11008240,9227530,27050101,2504721,23886875,-13117525,13958495,-5732453 },
+ },
+ {
+ { -23481610,4867226,-27247128,3900521,29838369,-8212291,-31889399,-10041781,7340521,-15410068 },
+ { 4646514,-8011124,-22766023,-11532654,23184553,8566613,31366726,-1381061,-15066784,-10375192 },
+ { -17270517,12723032,-16993061,14878794,21619651,-6197576,27584817,3093888,-8843694,3849921 },
+ },
+ {
+ { -9064912,2103172,25561640,-15125738,-5239824,9582958,32477045,-9017955,5002294,-15550259 },
+ { -12057553,-11177906,21115585,-13365155,8808712,-12030708,16489530,13378448,-25845716,12741426 },
+ { -5946367,10645103,-30911586,15390284,-3286982,-7118677,24306472,15852464,28834118,-7646072 },
+ },
+ {
+ { -17335748,-9107057,-24531279,9434953,-8472084,-583362,-13090771,455841,20461858,5491305 },
+ { 13669248,-16095482,-12481974,-10203039,-14569770,-11893198,-24995986,11293807,-28588204,-9421832 },
+ { 28497928,6272777,-33022994,14470570,8906179,-1225630,18504674,-14165166,29867745,-8795943 },
+ },
+ {
+ { -16207023,13517196,-27799630,-13697798,24009064,-6373891,-6367600,-13175392,22853429,-4012011 },
+ { 24191378,16712145,-13931797,15217831,14542237,1646131,18603514,-11037887,12876623,-2112447 },
+ { 17902668,4518229,-411702,-2829247,26878217,5258055,-12860753,608397,16031844,3723494 },
+ },
+ {
+ { -28632773,12763728,-20446446,7577504,33001348,-13017745,17558842,-7872890,23896954,-4314245 },
+ { -20005381,-12011952,31520464,605201,2543521,5991821,-2945064,7229064,-9919646,-8826859 },
+ { 28816045,298879,-28165016,-15920938,19000928,-1665890,-12680833,-2949325,-18051778,-2082915 },
+ },
+ {
+ { 16000882,-344896,3493092,-11447198,-29504595,-13159789,12577740,16041268,-19715240,7847707 },
+ { 10151868,10572098,27312476,7922682,14825339,4723128,-32855931,-6519018,-10020567,3852848 },
+ { -11430470,15697596,-21121557,-4420647,5386314,15063598,16514493,-15932110,29330899,-15076224 },
+ },
+},
+{
+ {
+ { -25499735,-4378794,-15222908,-6901211,16615731,2051784,3303702,15490,-27548796,12314391 },
+ { 15683520,-6003043,18109120,-9980648,15337968,-5997823,-16717435,15921866,16103996,-3731215 },
+ { -23169824,-10781249,13588192,-1628807,-3798557,-1074929,-19273607,5402699,-29815713,-9841101 },
+ },
+ {
+ { 23190676,2384583,-32714340,3462154,-29903655,-1529132,-11266856,8911517,-25205859,2739713 },
+ { 21374101,-3554250,-33524649,9874411,15377179,11831242,-33529904,6134907,4931255,11987849 },
+ { -7732,-2978858,-16223486,7277597,105524,-322051,-31480539,13861388,-30076310,10117930 },
+ },
+ {
+ { -29501170,-10744872,-26163768,13051539,-25625564,5089643,-6325503,6704079,12890019,15728940 },
+ { -21972360,-11771379,-951059,-4418840,14704840,2695116,903376,-10428139,12885167,8311031 },
+ { -17516482,5352194,10384213,-13811658,7506451,13453191,26423267,4384730,1888765,-5435404 },
+ },
+ {
+ { -25817338,-3107312,-13494599,-3182506,30896459,-13921729,-32251644,-12707869,-19464434,-3340243 },
+ { -23607977,-2665774,-526091,4651136,5765089,4618330,6092245,14845197,17151279,-9854116 },
+ { -24830458,-12733720,-15165978,10367250,-29530908,-265356,22825805,-7087279,-16866484,16176525 },
+ },
+ {
+ { -23583256,6564961,20063689,3798228,-4740178,7359225,2006182,-10363426,-28746253,-10197509 },
+ { -10626600,-4486402,-13320562,-5125317,3432136,-6393229,23632037,-1940610,32808310,1099883 },
+ { 15030977,5768825,-27451236,-2887299,-6427378,-15361371,-15277896,-6809350,2051441,-15225865 },
+ },
+ {
+ { -3362323,-7239372,7517890,9824992,23555850,295369,5148398,-14154188,-22686354,16633660 },
+ { 4577086,-16752288,13249841,-15304328,19958763,-14537274,18559670,-10759549,8402478,-9864273 },
+ { -28406330,-1051581,-26790155,-907698,-17212414,-11030789,9453451,-14980072,17983010,9967138 },
+ },
+ {
+ { -25762494,6524722,26585488,9969270,24709298,1220360,-1677990,7806337,17507396,3651560 },
+ { -10420457,-4118111,14584639,15971087,-15768321,8861010,26556809,-5574557,-18553322,-11357135 },
+ { 2839101,14284142,4029895,3472686,14402957,12689363,-26642121,8459447,-5605463,-7621941 },
+ },
+ {
+ { -4839289,-3535444,9744961,2871048,25113978,3187018,-25110813,-849066,17258084,-7977739 },
+ { 18164541,-10595176,-17154882,-1542417,19237078,-9745295,23357533,-15217008,26908270,12150756 },
+ { -30264870,-7647865,5112249,-7036672,-1499807,-6974257,43168,-5537701,-32302074,16215819 },
+ },
+},
+{
+ {
+ { -6898905,9824394,-12304779,-4401089,-31397141,-6276835,32574489,12532905,-7503072,-8675347 },
+ { -27343522,-16515468,-27151524,-10722951,946346,16291093,254968,7168080,21676107,-1943028 },
+ { 21260961,-8424752,-16831886,-11920822,-23677961,3968121,-3651949,-6215466,-3556191,-7913075 },
+ },
+ {
+ { 16544754,13250366,-16804428,15546242,-4583003,12757258,-2462308,-8680336,-18907032,-9662799 },
+ { -2415239,-15577728,18312303,4964443,-15272530,-12653564,26820651,16690659,25459437,-4564609 },
+ { -25144690,11425020,28423002,-11020557,-6144921,-15826224,9142795,-2391602,-6432418,-1644817 },
+ },
+ {
+ { -23104652,6253476,16964147,-3768872,-25113972,-12296437,-27457225,-16344658,6335692,7249989 },
+ { -30333227,13979675,7503222,-12368314,-11956721,-4621693,-30272269,2682242,25993170,-12478523 },
+ { 4364628,5930691,32304656,-10044554,-8054781,15091131,22857016,-10598955,31820368,15075278 },
+ },
+ {
+ { 31879134,-8918693,17258761,90626,-8041836,-4917709,24162788,-9650886,-17970238,12833045 },
+ { 19073683,14851414,-24403169,-11860168,7625278,11091125,-19619190,2074449,-9413939,14905377 },
+ { 24483667,-11935567,-2518866,-11547418,-1553130,15355506,-25282080,9253129,27628530,-7555480 },
+ },
+ {
+ { 17597607,8340603,19355617,552187,26198470,-3176583,4593324,-9157582,-14110875,15297016 },
+ { 510886,14337390,-31785257,16638632,6328095,2713355,-20217417,-11864220,8683221,2921426 },
+ { 18606791,11874196,27155355,-5281482,-24031742,6265446,-25178240,-1278924,4674690,13890525 },
+ },
+ {
+ { 13609624,13069022,-27372361,-13055908,24360586,9592974,14977157,9835105,4389687,288396 },
+ { 9922506,-519394,13613107,5883594,-18758345,-434263,-12304062,8317628,23388070,16052080 },
+ { 12720016,11937594,-31970060,-5028689,26900120,8561328,-20155687,-11632979,-14754271,-10812892 },
+ },
+ {
+ { 15961858,14150409,26716931,-665832,-22794328,13603569,11829573,7467844,-28822128,929275 },
+ { 11038231,-11582396,-27310482,-7316562,-10498527,-16307831,-23479533,-9371869,-21393143,2465074 },
+ { 20017163,-4323226,27915242,1529148,12396362,15675764,13817261,-9658066,2463391,-4622140 },
+ },
+ {
+ { -16358878,-12663911,-12065183,4996454,-1256422,1073572,9583558,12851107,4003896,12673717 },
+ { -1731589,-15155870,-3262930,16143082,19294135,13385325,14741514,-9103726,7903886,2348101 },
+ { 24536016,-16515207,12715592,-3862155,1511293,10047386,-3842346,-7129159,-28377538,10048127 },
+ },
+},
+{
+ {
+ { -12622226,-6204820,30718825,2591312,-10617028,12192840,18873298,-7297090,-32297756,15221632 },
+ { -26478122,-11103864,11546244,-1852483,9180880,7656409,-21343950,2095755,29769758,6593415 },
+ { -31994208,-2907461,4176912,3264766,12538965,-868111,26312345,-6118678,30958054,8292160 },
+ },
+ {
+ { 31429822,-13959116,29173532,15632448,12174511,-2760094,32808831,3977186,26143136,-3148876 },
+ { 22648901,1402143,-22799984,13746059,7936347,365344,-8668633,-1674433,-3758243,-2304625 },
+ { -15491917,8012313,-2514730,-12702462,-23965846,-10254029,-1612713,-1535569,-16664475,8194478 },
+ },
+ {
+ { 27338066,-7507420,-7414224,10140405,-19026427,-6589889,27277191,8855376,28572286,3005164 },
+ { 26287124,4821776,25476601,-4145903,-3764513,-15788984,-18008582,1182479,-26094821,-13079595 },
+ { -7171154,3178080,23970071,6201893,-17195577,-4489192,-21876275,-13982627,32208683,-1198248 },
+ },
+ {
+ { -16657702,2817643,-10286362,14811298,6024667,13349505,-27315504,-10497842,-27672585,-11539858 },
+ { 15941029,-9405932,-21367050,8062055,31876073,-238629,-15278393,-1444429,15397331,-4130193 },
+ { 8934485,-13485467,-23286397,-13423241,-32446090,14047986,31170398,-1441021,-27505566,15087184 },
+ },
+ {
+ { -18357243,-2156491,24524913,-16677868,15520427,-6360776,-15502406,11461896,16788528,-5868942 },
+ { -1947386,16013773,21750665,3714552,-17401782,-16055433,-3770287,-10323320,31322514,-11615635 },
+ { 21426655,-5650218,-13648287,-5347537,-28812189,-4920970,-18275391,-14621414,13040862,-12112948 },
+ },
+ {
+ { 11293895,12478086,-27136401,15083750,-29307421,14748872,14555558,-13417103,1613711,4896935 },
+ { -25894883,15323294,-8489791,-8057900,25967126,-13425460,2825960,-4897045,-23971776,-11267415 },
+ { -15924766,-5229880,-17443532,6410664,3622847,10243618,20615400,12405433,-23753030,-8436416 },
+ },
+ {
+ { -7091295,12556208,-20191352,9025187,-17072479,4333801,4378436,2432030,23097949,-566018 },
+ { 4565804,-16025654,20084412,-7842817,1724999,189254,24767264,10103221,-18512313,2424778 },
+ { 366633,-11976806,8173090,-6890119,30788634,5745705,-7168678,1344109,-3642553,12412659 },
+ },
+ {
+ { -24001791,7690286,14929416,-168257,-32210835,-13412986,24162697,-15326504,-3141501,11179385 },
+ { 18289522,-14724954,8056945,16430056,-21729724,7842514,-6001441,-1486897,-18684645,-11443503 },
+ { 476239,6601091,-6152790,-9723375,17503545,-4863900,27672959,13403813,11052904,5219329 },
+ },
+},
+{
+ {
+ { 20678546,-8375738,-32671898,8849123,-5009758,14574752,31186971,-3973730,9014762,-8579056 },
+ { -13644050,-10350239,-15962508,5075808,-1514661,-11534600,-33102500,9160280,8473550,-3256838 },
+ { 24900749,14435722,17209120,-15292541,-22592275,9878983,-7689309,-16335821,-24568481,11788948 },
+ },
+ {
+ { -3118155,-11395194,-13802089,14797441,9652448,-6845904,-20037437,10410733,-24568470,-1458691 },
+ { -15659161,16736706,-22467150,10215878,-9097177,7563911,11871841,-12505194,-18513325,8464118 },
+ { -23400612,8348507,-14585951,-861714,-3950205,-6373419,14325289,8628612,33313881,-8370517 },
+ },
+ {
+ { -20186973,-4967935,22367356,5271547,-1097117,-4788838,-24805667,-10236854,-8940735,-5818269 },
+ { -6948785,-1795212,-32625683,-16021179,32635414,-7374245,15989197,-12838188,28358192,-4253904 },
+ { -23561781,-2799059,-32351682,-1661963,-9147719,10429267,-16637684,4072016,-5351664,5596589 },
+ },
+ {
+ { -28236598,-3390048,12312896,6213178,3117142,16078565,29266239,2557221,1768301,15373193 },
+ { -7243358,-3246960,-4593467,-7553353,-127927,-912245,-1090902,-4504991,-24660491,3442910 },
+ { -30210571,5124043,14181784,8197961,18964734,-11939093,22597931,7176455,-18585478,13365930 },
+ },
+ {
+ { -7877390,-1499958,8324673,4690079,6261860,890446,24538107,-8570186,-9689599,-3031667 },
+ { 25008904,-10771599,-4305031,-9638010,16265036,15721635,683793,-11823784,15723479,-15163481 },
+ { -9660625,12374379,-27006999,-7026148,-7724114,-12314514,11879682,5400171,519526,-1235876 },
+ },
+ {
+ { 22258397,-16332233,-7869817,14613016,-22520255,-2950923,-20353881,7315967,16648397,7605640 },
+ { -8081308,-8464597,-8223311,9719710,19259459,-15348212,23994942,-5281555,-9468848,4763278 },
+ { -21699244,9220969,-15730624,1084137,-25476107,-2852390,31088447,-7764523,-11356529,728112 },
+ },
+ {
+ { 26047220,-11751471,-6900323,-16521798,24092068,9158119,-4273545,-12555558,-29365436,-5498272 },
+ { 17510331,-322857,5854289,8403524,17133918,-3112612,-28111007,12327945,10750447,10014012 },
+ { -10312768,3936952,9156313,-8897683,16498692,-994647,-27481051,-666732,3424691,7540221 },
+ },
+ {
+ { 30322361,-6964110,11361005,-4143317,7433304,4989748,-7071422,-16317219,-9244265,15258046 },
+ { 13054562,-2779497,19155474,469045,-12482797,4566042,5631406,2711395,1062915,-5136345 },
+ { -19240248,-11254599,-29509029,-7499965,-5835763,13005411,-6066489,12194497,32960380,1459310 },
+ },
+},
+{
+ {
+ { 19852034,7027924,23669353,10020366,8586503,-6657907,394197,-6101885,18638003,-11174937 },
+ { 31395534,15098109,26581030,8030562,-16527914,-5007134,9012486,-7584354,-6643087,-5442636 },
+ { -9192165,-2347377,-1997099,4529534,25766844,607986,-13222,9677543,-32294889,-6456008 },
+ },
+ {
+ { -2444496,-149937,29348902,8186665,1873760,12489863,-30934579,-7839692,-7852844,-8138429 },
+ { -15236356,-15433509,7766470,746860,26346930,-10221762,-27333451,10754588,-9431476,5203576 },
+ { 31834314,14135496,-770007,5159118,20917671,-16768096,-7467973,-7337524,31809243,7347066 },
+ },
+ {
+ { -9606723,-11874240,20414459,13033986,13716524,-11691881,19797970,-12211255,15192876,-2087490 },
+ { -12663563,-2181719,1168162,-3804809,26747877,-14138091,10609330,12694420,33473243,-13382104 },
+ { 33184999,11180355,15832085,-11385430,-1633671,225884,15089336,-11023903,-6135662,14480053 },
+ },
+ {
+ { 31308717,-5619998,31030840,-1897099,15674547,-6582883,5496208,13685227,27595050,8737275 },
+ { -20318852,-15150239,10933843,-16178022,8335352,-7546022,-31008351,-12610604,26498114,66511 },
+ { 22644454,-8761729,-16671776,4884562,-3105614,-13559366,30540766,-4286747,-13327787,-7515095 },
+ },
+ {
+ { -28017847,9834845,18617207,-2681312,-3401956,-13307506,8205540,13585437,-17127465,15115439 },
+ { 23711543,-672915,31206561,-8362711,6164647,-9709987,-33535882,-1426096,8236921,16492939 },
+ { -23910559,-13515526,-26299483,-4503841,25005590,-7687270,19574902,10071562,6708380,-6222424 },
+ },
+ {
+ { 2101391,-4930054,19702731,2367575,-15427167,1047675,5301017,9328700,29955601,-11678310 },
+ { 3096359,9271816,-21620864,-15521844,-14847996,-7592937,-25892142,-12635595,-9917575,6216608 },
+ { -32615849,338663,-25195611,2510422,-29213566,-13820213,24822830,-6146567,-26767480,7525079 },
+ },
+ {
+ { -23066649,-13985623,16133487,-7896178,-3389565,778788,-910336,-2782495,-19386633,11994101 },
+ { 21691500,-13624626,-641331,-14367021,3285881,-3483596,-25064666,9718258,-7477437,13381418 },
+ { 18445390,-4202236,14979846,11622458,-1727110,-3582980,23111648,-6375247,28535282,15779576 },
+ },
+ {
+ { 30098053,3089662,-9234387,16662135,-21306940,11308411,-14068454,12021730,9955285,-16303356 },
+ { 9734894,-14576830,-7473633,-9138735,2060392,11313496,-18426029,9924399,20194861,13380996 },
+ { -26378102,-7965207,-22167821,15789297,-18055342,-6168792,-1984914,15707771,26342023,10146099 },
+ },
+},
+{
+ {
+ { -26016874,-219943,21339191,-41388,19745256,-2878700,-29637280,2227040,21612326,-545728 },
+ { -13077387,1184228,23562814,-5970442,-20351244,-6348714,25764461,12243797,-20856566,11649658 },
+ { -10031494,11262626,27384172,2271902,26947504,-15997771,39944,6114064,33514190,2333242 },
+ },
+ {
+ { -21433588,-12421821,8119782,7219913,-21830522,-9016134,-6679750,-12670638,24350578,-13450001 },
+ { -4116307,-11271533,-23886186,4843615,-30088339,690623,-31536088,-10406836,8317860,12352766 },
+ { 18200138,-14475911,-33087759,-2696619,-23702521,-9102511,-23552096,-2287550,20712163,6719373 },
+ },
+ {
+ { 26656208,6075253,-7858556,1886072,-28344043,4262326,11117530,-3763210,26224235,-3297458 },
+ { -17168938,-14854097,-3395676,-16369877,-19954045,14050420,21728352,9493610,18620611,-16428628 },
+ { -13323321,13325349,11432106,5964811,18609221,6062965,-5269471,-9725556,-30701573,-16479657 },
+ },
+ {
+ { -23860538,-11233159,26961357,1640861,-32413112,-16737940,12248509,-5240639,13735342,1934062 },
+ { 25089769,6742589,17081145,-13406266,21909293,-16067981,-15136294,-3765346,-21277997,5473616 },
+ { 31883677,-7961101,1083432,-11572403,22828471,13290673,-7125085,12469656,29111212,-5451014 },
+ },
+ {
+ { 24244947,-15050407,-26262976,2791540,-14997599,16666678,24367466,6388839,-10295587,452383 },
+ { -25640782,-3417841,5217916,16224624,19987036,-4082269,-24236251,-5915248,15766062,8407814 },
+ { -20406999,13990231,15495425,16395525,5377168,15166495,-8917023,-4388953,-8067909,2276718 },
+ },
+ {
+ { 30157918,12924066,-17712050,9245753,19895028,3368142,-23827587,5096219,22740376,-7303417 },
+ { 2041139,-14256350,7783687,13876377,-25946985,-13352459,24051124,13742383,-15637599,13295222 },
+ { 33338237,-8505733,12532113,7977527,9106186,-1715251,-17720195,-4612972,-4451357,-14669444 },
+ },
+ {
+ { -20045281,5454097,-14346548,6447146,28862071,1883651,-2469266,-4141880,7770569,9620597 },
+ { 23208068,7979712,33071466,8149229,1758231,-10834995,30945528,-1694323,-33502340,-14767970 },
+ { 1439958,-16270480,-1079989,-793782,4625402,10647766,-5043801,1220118,30494170,-11440799 },
+ },
+ {
+ { -5037580,-13028295,-2970559,-3061767,15640974,-6701666,-26739026,926050,-1684339,-13333647 },
+ { 13908495,-3549272,30919928,-6273825,-21521863,7989039,9021034,9078865,3353509,4033511 },
+ { -29663431,-15113610,32259991,-344482,24295849,-12912123,23161163,8839127,27485041,7356032 },
+ },
+},
+{
+ {
+ { 9661027,705443,11980065,-5370154,-1628543,14661173,-6346142,2625015,28431036,-16771834 },
+ { -23839233,-8311415,-25945511,7480958,-17681669,-8354183,-22545972,14150565,15970762,4099461 },
+ { 29262576,16756590,26350592,-8793563,8529671,-11208050,13617293,-9937143,11465739,8317062 },
+ },
+ {
+ { -25493081,-6962928,32500200,-9419051,-23038724,-2302222,14898637,3848455,20969334,-5157516 },
+ { -20384450,-14347713,-18336405,13884722,-33039454,2842114,-21610826,-3649888,11177095,14989547 },
+ { -24496721,-11716016,16959896,2278463,12066309,10137771,13515641,2581286,-28487508,9930240 },
+ },
+ {
+ { -17751622,-2097826,16544300,-13009300,-15914807,-14949081,18345767,-13403753,16291481,-5314038 },
+ { -33229194,2553288,32678213,9875984,8534129,6889387,-9676774,6957617,4368891,9788741 },
+ { 16660756,7281060,-10830758,12911820,20108584,-8101676,-21722536,-8613148,16250552,-11111103 },
+ },
+ {
+ { -19765507,2390526,-16551031,14161980,1905286,6414907,4689584,10604807,-30190403,4782747 },
+ { -1354539,14736941,-7367442,-13292886,7710542,-14155590,-9981571,4383045,22546403,437323 },
+ { 31665577,-12180464,-16186830,1491339,-18368625,3294682,27343084,2786261,-30633590,-14097016 },
+ },
+ {
+ { -14467279,-683715,-33374107,7448552,19294360,14334329,-19690631,2355319,-19284671,-6114373 },
+ { 15121312,-15796162,6377020,-6031361,-10798111,-12957845,18952177,15496498,-29380133,11754228 },
+ { -2637277,-13483075,8488727,-14303896,12728761,-1622493,7141596,11724556,22761615,-10134141 },
+ },
+ {
+ { 16918416,11729663,-18083579,3022987,-31015732,-13339659,-28741185,-12227393,32851222,11717399 },
+ { 11166634,7338049,-6722523,4531520,-29468672,-7302055,31474879,3483633,-1193175,-4030831 },
+ { -185635,9921305,31456609,-13536438,-12013818,13348923,33142652,6546660,-19985279,-3948376 },
+ },
+ {
+ { -32460596,11266712,-11197107,-7899103,31703694,3855903,-8537131,-12833048,-30772034,-15486313 },
+ { -18006477,12709068,3991746,-6479188,-21491523,-10550425,-31135347,-16049879,10928917,3011958 },
+ { -6957757,-15594337,31696059,334240,29576716,14796075,-30831056,-12805180,18008031,10258577 },
+ },
+ {
+ { -22448644,15655569,7018479,-4410003,-30314266,-1201591,-1853465,1367120,25127874,6671743 },
+ { 29701166,-14373934,-10878120,9279288,-17568,13127210,21382910,11042292,25838796,4642684 },
+ { -20430234,14955537,-24126347,8124619,-5369288,-5990470,30468147,-13900640,18423289,4177476 },
+ },
+},
diff --git a/jni/ed25519/base2.h b/jni/ed25519/base2.h
new file mode 100644
index 00000000..8c538440
--- /dev/null
+++ b/jni/ed25519/base2.h
@@ -0,0 +1,40 @@
+ {
+ { 25967493,-14356035,29566456,3660896,-12694345,4014787,27544626,-11754271,-6079156,2047605 },
+ { -12545711,934262,-2722910,3049990,-727428,9406986,12720692,5043384,19500929,-15469378 },
+ { -8738181,4489570,9688441,-14785194,10184609,-12363380,29287919,11864899,-24514362,-4438546 },
+ },
+ {
+ { 15636291,-9688557,24204773,-7912398,616977,-16685262,27787600,-14772189,28944400,-1550024 },
+ { 16568933,4717097,-11556148,-1102322,15682896,-11807043,16354577,-11775962,7689662,11199574 },
+ { 30464156,-5976125,-11779434,-15670865,23220365,15915852,7512774,10017326,-17749093,-9920357 },
+ },
+ {
+ { 10861363,11473154,27284546,1981175,-30064349,12577861,32867885,14515107,-15438304,10819380 },
+ { 4708026,6336745,20377586,9066809,-11272109,6594696,-25653668,12483688,-12668491,5581306 },
+ { 19563160,16186464,-29386857,4097519,10237984,-4348115,28542350,13850243,-23678021,-15815942 },
+ },
+ {
+ { 5153746,9909285,1723747,-2777874,30523605,5516873,19480852,5230134,-23952439,-15175766 },
+ { -30269007,-3463509,7665486,10083793,28475525,1649722,20654025,16520125,30598449,7715701 },
+ { 28881845,14381568,9657904,3680757,-20181635,7843316,-31400660,1370708,29794553,-1409300 },
+ },
+ {
+ { -22518993,-6692182,14201702,-8745502,-23510406,8844726,18474211,-1361450,-13062696,13821877 },
+ { -6455177,-7839871,3374702,-4740862,-27098617,-10571707,31655028,-7212327,18853322,-14220951 },
+ { 4566830,-12963868,-28974889,-12240689,-7602672,-2830569,-8514358,-10431137,2207753,-3209784 },
+ },
+ {
+ { -25154831,-4185821,29681144,7868801,-6854661,-9423865,-12437364,-663000,-31111463,-16132436 },
+ { 25576264,-2703214,7349804,-11814844,16472782,9300885,3844789,15725684,171356,6466918 },
+ { 23103977,13316479,9739013,-16149481,817875,-15038942,8965339,-14088058,-30714912,16193877 },
+ },
+ {
+ { -33521811,3180713,-2394130,14003687,-16903474,-16270840,17238398,4729455,-18074513,9256800 },
+ { -25182317,-4174131,32336398,5036987,-21236817,11360617,22616405,9761698,-19827198,630305 },
+ { -13720693,2639453,-24237460,-7406481,9494427,-5774029,-6554551,-15960994,-2449256,-14291300 },
+ },
+ {
+ { -3151181,-5046075,9282714,6866145,-31907062,-863023,-18940575,15033784,25105118,-7894876 },
+ { -24326370,15950226,-31801215,-14592823,-11662737,-5090925,1573892,-2625887,2198790,-15804619 },
+ { -3099351,10324967,-2241613,7453183,-5446979,-2735503,-13812022,-16236442,-32461234,-12290683 },
+ },
diff --git a/jni/ed25519/d.h b/jni/ed25519/d.h
new file mode 100644
index 00000000..e25f5783
--- /dev/null
+++ b/jni/ed25519/d.h
@@ -0,0 +1 @@
+-10913610,13857413,-15372611,6949391,114729,-8787816,-6275908,-3247719,-18696448,-12055116
diff --git a/jni/ed25519/d2.h b/jni/ed25519/d2.h
new file mode 100644
index 00000000..01aaec75
--- /dev/null
+++ b/jni/ed25519/d2.h
@@ -0,0 +1 @@
+-21827239,-5839606,-30745221,13898782,229458,15978800,-12551817,-6495438,29715968,9444199
diff --git a/jni/ed25519/fe.h b/jni/ed25519/fe.h
new file mode 100644
index 00000000..60c308ba
--- /dev/null
+++ b/jni/ed25519/fe.h
@@ -0,0 +1,56 @@
+#ifndef FE_H
+#define FE_H
+
+#include "crypto_int32.h"
+
+typedef crypto_int32 fe[10];
+
+/*
+fe means field element.
+Here the field is \Z/(2^255-19).
+An element t, entries t[0]...t[9], represents the integer
+t[0]+2^26 t[1]+2^51 t[2]+2^77 t[3]+2^102 t[4]+...+2^230 t[9].
+Bounds on each t[i] vary depending on context.
+*/
+
+#define fe_frombytes crypto_sign_ed25519_ref10_fe_frombytes
+#define fe_tobytes crypto_sign_ed25519_ref10_fe_tobytes
+#define fe_copy crypto_sign_ed25519_ref10_fe_copy
+#define fe_isnonzero crypto_sign_ed25519_ref10_fe_isnonzero
+#define fe_isnegative crypto_sign_ed25519_ref10_fe_isnegative
+#define fe_0 crypto_sign_ed25519_ref10_fe_0
+#define fe_1 crypto_sign_ed25519_ref10_fe_1
+#define fe_cswap crypto_sign_ed25519_ref10_fe_cswap
+#define fe_cmov crypto_sign_ed25519_ref10_fe_cmov
+#define fe_add crypto_sign_ed25519_ref10_fe_add
+#define fe_sub crypto_sign_ed25519_ref10_fe_sub
+#define fe_neg crypto_sign_ed25519_ref10_fe_neg
+#define fe_mul crypto_sign_ed25519_ref10_fe_mul
+#define fe_sq crypto_sign_ed25519_ref10_fe_sq
+#define fe_sq2 crypto_sign_ed25519_ref10_fe_sq2
+#define fe_mul121666 crypto_sign_ed25519_ref10_fe_mul121666
+#define fe_invert crypto_sign_ed25519_ref10_fe_invert
+#define fe_pow22523 crypto_sign_ed25519_ref10_fe_pow22523
+
+extern void fe_frombytes(fe,const unsigned char *);
+extern void fe_tobytes(unsigned char *,const fe);
+
+extern void fe_copy(fe,const fe);
+extern int fe_isnonzero(const fe);
+extern int fe_isnegative(const fe);
+extern void fe_0(fe);
+extern void fe_1(fe);
+extern void fe_cswap(fe,fe,unsigned int);
+extern void fe_cmov(fe,const fe,unsigned int);
+
+extern void fe_add(fe,const fe,const fe);
+extern void fe_sub(fe,const fe,const fe);
+extern void fe_neg(fe,const fe);
+extern void fe_mul(fe,const fe,const fe);
+extern void fe_sq(fe,const fe);
+extern void fe_sq2(fe,const fe);
+extern void fe_mul121666(fe,const fe);
+extern void fe_invert(fe,const fe);
+extern void fe_pow22523(fe,const fe);
+
+#endif
diff --git a/jni/ed25519/fe_0.c b/jni/ed25519/fe_0.c
new file mode 100644
index 00000000..ec879d73
--- /dev/null
+++ b/jni/ed25519/fe_0.c
@@ -0,0 +1,19 @@
+#include "fe.h"
+
+/*
+h = 0
+*/
+
+void fe_0(fe h)
+{
+ h[0] = 0;
+ h[1] = 0;
+ h[2] = 0;
+ h[3] = 0;
+ h[4] = 0;
+ h[5] = 0;
+ h[6] = 0;
+ h[7] = 0;
+ h[8] = 0;
+ h[9] = 0;
+}
diff --git a/jni/ed25519/fe_1.c b/jni/ed25519/fe_1.c
new file mode 100644
index 00000000..8cf77848
--- /dev/null
+++ b/jni/ed25519/fe_1.c
@@ -0,0 +1,19 @@
+#include "fe.h"
+
+/*
+h = 1
+*/
+
+void fe_1(fe h)
+{
+ h[0] = 1;
+ h[1] = 0;
+ h[2] = 0;
+ h[3] = 0;
+ h[4] = 0;
+ h[5] = 0;
+ h[6] = 0;
+ h[7] = 0;
+ h[8] = 0;
+ h[9] = 0;
+}
diff --git a/jni/ed25519/fe_add.c b/jni/ed25519/fe_add.c
new file mode 100644
index 00000000..e6a81da2
--- /dev/null
+++ b/jni/ed25519/fe_add.c
@@ -0,0 +1,57 @@
+#include "fe.h"
+
+/*
+h = f + g
+Can overlap h with f or g.
+
+Preconditions:
+ |f| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+ |g| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+
+Postconditions:
+ |h| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
+*/
+
+void fe_add(fe h,const fe f,const fe g)
+{
+ crypto_int32 f0 = f[0];
+ crypto_int32 f1 = f[1];
+ crypto_int32 f2 = f[2];
+ crypto_int32 f3 = f[3];
+ crypto_int32 f4 = f[4];
+ crypto_int32 f5 = f[5];
+ crypto_int32 f6 = f[6];
+ crypto_int32 f7 = f[7];
+ crypto_int32 f8 = f[8];
+ crypto_int32 f9 = f[9];
+ crypto_int32 g0 = g[0];
+ crypto_int32 g1 = g[1];
+ crypto_int32 g2 = g[2];
+ crypto_int32 g3 = g[3];
+ crypto_int32 g4 = g[4];
+ crypto_int32 g5 = g[5];
+ crypto_int32 g6 = g[6];
+ crypto_int32 g7 = g[7];
+ crypto_int32 g8 = g[8];
+ crypto_int32 g9 = g[9];
+ crypto_int32 h0 = f0 + g0;
+ crypto_int32 h1 = f1 + g1;
+ crypto_int32 h2 = f2 + g2;
+ crypto_int32 h3 = f3 + g3;
+ crypto_int32 h4 = f4 + g4;
+ crypto_int32 h5 = f5 + g5;
+ crypto_int32 h6 = f6 + g6;
+ crypto_int32 h7 = f7 + g7;
+ crypto_int32 h8 = f8 + g8;
+ crypto_int32 h9 = f9 + g9;
+ h[0] = h0;
+ h[1] = h1;
+ h[2] = h2;
+ h[3] = h3;
+ h[4] = h4;
+ h[5] = h5;
+ h[6] = h6;
+ h[7] = h7;
+ h[8] = h8;
+ h[9] = h9;
+}
diff --git a/jni/ed25519/fe_cmov.c b/jni/ed25519/fe_cmov.c
new file mode 100644
index 00000000..8ca584fb
--- /dev/null
+++ b/jni/ed25519/fe_cmov.c
@@ -0,0 +1,63 @@
+#include "fe.h"
+
+/*
+Replace (f,g) with (g,g) if b == 1;
+replace (f,g) with (f,g) if b == 0.
+
+Preconditions: b in {0,1}.
+*/
+
+void fe_cmov(fe f,const fe g,unsigned int b)
+{
+ crypto_int32 f0 = f[0];
+ crypto_int32 f1 = f[1];
+ crypto_int32 f2 = f[2];
+ crypto_int32 f3 = f[3];
+ crypto_int32 f4 = f[4];
+ crypto_int32 f5 = f[5];
+ crypto_int32 f6 = f[6];
+ crypto_int32 f7 = f[7];
+ crypto_int32 f8 = f[8];
+ crypto_int32 f9 = f[9];
+ crypto_int32 g0 = g[0];
+ crypto_int32 g1 = g[1];
+ crypto_int32 g2 = g[2];
+ crypto_int32 g3 = g[3];
+ crypto_int32 g4 = g[4];
+ crypto_int32 g5 = g[5];
+ crypto_int32 g6 = g[6];
+ crypto_int32 g7 = g[7];
+ crypto_int32 g8 = g[8];
+ crypto_int32 g9 = g[9];
+ crypto_int32 x0 = f0 ^ g0;
+ crypto_int32 x1 = f1 ^ g1;
+ crypto_int32 x2 = f2 ^ g2;
+ crypto_int32 x3 = f3 ^ g3;
+ crypto_int32 x4 = f4 ^ g4;
+ crypto_int32 x5 = f5 ^ g5;
+ crypto_int32 x6 = f6 ^ g6;
+ crypto_int32 x7 = f7 ^ g7;
+ crypto_int32 x8 = f8 ^ g8;
+ crypto_int32 x9 = f9 ^ g9;
+ b = -b;
+ x0 &= b;
+ x1 &= b;
+ x2 &= b;
+ x3 &= b;
+ x4 &= b;
+ x5 &= b;
+ x6 &= b;
+ x7 &= b;
+ x8 &= b;
+ x9 &= b;
+ f[0] = f0 ^ x0;
+ f[1] = f1 ^ x1;
+ f[2] = f2 ^ x2;
+ f[3] = f3 ^ x3;
+ f[4] = f4 ^ x4;
+ f[5] = f5 ^ x5;
+ f[6] = f6 ^ x6;
+ f[7] = f7 ^ x7;
+ f[8] = f8 ^ x8;
+ f[9] = f9 ^ x9;
+}
diff --git a/jni/ed25519/fe_copy.c b/jni/ed25519/fe_copy.c
new file mode 100644
index 00000000..9c5bf865
--- /dev/null
+++ b/jni/ed25519/fe_copy.c
@@ -0,0 +1,29 @@
+#include "fe.h"
+
+/*
+h = f
+*/
+
+void fe_copy(fe h,const fe f)
+{
+ crypto_int32 f0 = f[0];
+ crypto_int32 f1 = f[1];
+ crypto_int32 f2 = f[2];
+ crypto_int32 f3 = f[3];
+ crypto_int32 f4 = f[4];
+ crypto_int32 f5 = f[5];
+ crypto_int32 f6 = f[6];
+ crypto_int32 f7 = f[7];
+ crypto_int32 f8 = f[8];
+ crypto_int32 f9 = f[9];
+ h[0] = f0;
+ h[1] = f1;
+ h[2] = f2;
+ h[3] = f3;
+ h[4] = f4;
+ h[5] = f5;
+ h[6] = f6;
+ h[7] = f7;
+ h[8] = f8;
+ h[9] = f9;
+}
diff --git a/jni/ed25519/fe_frombytes.c b/jni/ed25519/fe_frombytes.c
new file mode 100644
index 00000000..5c179174
--- /dev/null
+++ b/jni/ed25519/fe_frombytes.c
@@ -0,0 +1,73 @@
+#include "fe.h"
+#include "crypto_int64.h"
+#include "crypto_uint64.h"
+
+static crypto_uint64 load_3(const unsigned char *in)
+{
+ crypto_uint64 result;
+ result = (crypto_uint64) in[0];
+ result |= ((crypto_uint64) in[1]) << 8;
+ result |= ((crypto_uint64) in[2]) << 16;
+ return result;
+}
+
+static crypto_uint64 load_4(const unsigned char *in)
+{
+ crypto_uint64 result;
+ result = (crypto_uint64) in[0];
+ result |= ((crypto_uint64) in[1]) << 8;
+ result |= ((crypto_uint64) in[2]) << 16;
+ result |= ((crypto_uint64) in[3]) << 24;
+ return result;
+}
+
+/*
+Ignores top bit of h.
+*/
+
+void fe_frombytes(fe h,const unsigned char *s)
+{
+ crypto_int64 h0 = load_4(s);
+ crypto_int64 h1 = load_3(s + 4) << 6;
+ crypto_int64 h2 = load_3(s + 7) << 5;
+ crypto_int64 h3 = load_3(s + 10) << 3;
+ crypto_int64 h4 = load_3(s + 13) << 2;
+ crypto_int64 h5 = load_4(s + 16);
+ crypto_int64 h6 = load_3(s + 20) << 7;
+ crypto_int64 h7 = load_3(s + 23) << 5;
+ crypto_int64 h8 = load_3(s + 26) << 4;
+ crypto_int64 h9 = (load_3(s + 29) & 8388607) << 2;
+ crypto_int64 carry0;
+ crypto_int64 carry1;
+ crypto_int64 carry2;
+ crypto_int64 carry3;
+ crypto_int64 carry4;
+ crypto_int64 carry5;
+ crypto_int64 carry6;
+ crypto_int64 carry7;
+ crypto_int64 carry8;
+ crypto_int64 carry9;
+
+ carry9 = (h9 + (crypto_int64) (1<<24)) >> 25; h0 += carry9 * 19; h9 -= carry9 << 25;
+ carry1 = (h1 + (crypto_int64) (1<<24)) >> 25; h2 += carry1; h1 -= carry1 << 25;
+ carry3 = (h3 + (crypto_int64) (1<<24)) >> 25; h4 += carry3; h3 -= carry3 << 25;
+ carry5 = (h5 + (crypto_int64) (1<<24)) >> 25; h6 += carry5; h5 -= carry5 << 25;
+ carry7 = (h7 + (crypto_int64) (1<<24)) >> 25; h8 += carry7; h7 -= carry7 << 25;
+
+ carry0 = (h0 + (crypto_int64) (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
+ carry2 = (h2 + (crypto_int64) (1<<25)) >> 26; h3 += carry2; h2 -= carry2 << 26;
+ carry4 = (h4 + (crypto_int64) (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
+ carry6 = (h6 + (crypto_int64) (1<<25)) >> 26; h7 += carry6; h6 -= carry6 << 26;
+ carry8 = (h8 + (crypto_int64) (1<<25)) >> 26; h9 += carry8; h8 -= carry8 << 26;
+
+ h[0] = h0;
+ h[1] = h1;
+ h[2] = h2;
+ h[3] = h3;
+ h[4] = h4;
+ h[5] = h5;
+ h[6] = h6;
+ h[7] = h7;
+ h[8] = h8;
+ h[9] = h9;
+}
diff --git a/jni/ed25519/fe_invert.c b/jni/ed25519/fe_invert.c
new file mode 100644
index 00000000..bcfdb8ff
--- /dev/null
+++ b/jni/ed25519/fe_invert.c
@@ -0,0 +1,14 @@
+#include "fe.h"
+
+void fe_invert(fe out,const fe z)
+{
+ fe t0;
+ fe t1;
+ fe t2;
+ fe t3;
+ int i;
+
+#include "pow225521.h"
+
+ return;
+}
diff --git a/jni/ed25519/fe_isnegative.c b/jni/ed25519/fe_isnegative.c
new file mode 100644
index 00000000..3b2c8b8d
--- /dev/null
+++ b/jni/ed25519/fe_isnegative.c
@@ -0,0 +1,16 @@
+#include "fe.h"
+
+/*
+return 1 if f is in {1,3,5,...,q-2}
+return 0 if f is in {0,2,4,...,q-1}
+
+Preconditions:
+ |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
+*/
+
+int fe_isnegative(const fe f)
+{
+ unsigned char s[32];
+ fe_tobytes(s,f);
+ return s[0] & 1;
+}
diff --git a/jni/ed25519/fe_isnonzero.c b/jni/ed25519/fe_isnonzero.c
new file mode 100644
index 00000000..47568001
--- /dev/null
+++ b/jni/ed25519/fe_isnonzero.c
@@ -0,0 +1,19 @@
+#include "fe.h"
+#include "crypto_verify_32.h"
+
+/*
+return 1 if f == 0
+return 0 if f != 0
+
+Preconditions:
+ |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
+*/
+
+static const unsigned char zero[32];
+
+int fe_isnonzero(const fe f)
+{
+ unsigned char s[32];
+ fe_tobytes(s,f);
+ return crypto_verify_32(s,zero);
+}
diff --git a/jni/ed25519/fe_mul.c b/jni/ed25519/fe_mul.c
new file mode 100644
index 00000000..26ca8b36
--- /dev/null
+++ b/jni/ed25519/fe_mul.c
@@ -0,0 +1,253 @@
+#include "fe.h"
+#include "crypto_int64.h"
+
+/*
+h = f * g
+Can overlap h with f or g.
+
+Preconditions:
+ |f| bounded by 1.65*2^26,1.65*2^25,1.65*2^26,1.65*2^25,etc.
+ |g| bounded by 1.65*2^26,1.65*2^25,1.65*2^26,1.65*2^25,etc.
+
+Postconditions:
+ |h| bounded by 1.01*2^25,1.01*2^24,1.01*2^25,1.01*2^24,etc.
+*/
+
+/*
+Notes on implementation strategy:
+
+Using schoolbook multiplication.
+Karatsuba would save a little in some cost models.
+
+Most multiplications by 2 and 19 are 32-bit precomputations;
+cheaper than 64-bit postcomputations.
+
+There is one remaining multiplication by 19 in the carry chain;
+one *19 precomputation can be merged into this,
+but the resulting data flow is considerably less clean.
+
+There are 12 carries below.
+10 of them are 2-way parallelizable and vectorizable.
+Can get away with 11 carries, but then data flow is much deeper.
+
+With tighter constraints on inputs can squeeze carries into int32.
+*/
+
+void fe_mul(fe h,const fe f,const fe g)
+{
+ crypto_int32 f0 = f[0];
+ crypto_int32 f1 = f[1];
+ crypto_int32 f2 = f[2];
+ crypto_int32 f3 = f[3];
+ crypto_int32 f4 = f[4];
+ crypto_int32 f5 = f[5];
+ crypto_int32 f6 = f[6];
+ crypto_int32 f7 = f[7];
+ crypto_int32 f8 = f[8];
+ crypto_int32 f9 = f[9];
+ crypto_int32 g0 = g[0];
+ crypto_int32 g1 = g[1];
+ crypto_int32 g2 = g[2];
+ crypto_int32 g3 = g[3];
+ crypto_int32 g4 = g[4];
+ crypto_int32 g5 = g[5];
+ crypto_int32 g6 = g[6];
+ crypto_int32 g7 = g[7];
+ crypto_int32 g8 = g[8];
+ crypto_int32 g9 = g[9];
+ crypto_int32 g1_19 = 19 * g1; /* 1.959375*2^29 */
+ crypto_int32 g2_19 = 19 * g2; /* 1.959375*2^30; still ok */
+ crypto_int32 g3_19 = 19 * g3;
+ crypto_int32 g4_19 = 19 * g4;
+ crypto_int32 g5_19 = 19 * g5;
+ crypto_int32 g6_19 = 19 * g6;
+ crypto_int32 g7_19 = 19 * g7;
+ crypto_int32 g8_19 = 19 * g8;
+ crypto_int32 g9_19 = 19 * g9;
+ crypto_int32 f1_2 = 2 * f1;
+ crypto_int32 f3_2 = 2 * f3;
+ crypto_int32 f5_2 = 2 * f5;
+ crypto_int32 f7_2 = 2 * f7;
+ crypto_int32 f9_2 = 2 * f9;
+ crypto_int64 f0g0 = f0 * (crypto_int64) g0;
+ crypto_int64 f0g1 = f0 * (crypto_int64) g1;
+ crypto_int64 f0g2 = f0 * (crypto_int64) g2;
+ crypto_int64 f0g3 = f0 * (crypto_int64) g3;
+ crypto_int64 f0g4 = f0 * (crypto_int64) g4;
+ crypto_int64 f0g5 = f0 * (crypto_int64) g5;
+ crypto_int64 f0g6 = f0 * (crypto_int64) g6;
+ crypto_int64 f0g7 = f0 * (crypto_int64) g7;
+ crypto_int64 f0g8 = f0 * (crypto_int64) g8;
+ crypto_int64 f0g9 = f0 * (crypto_int64) g9;
+ crypto_int64 f1g0 = f1 * (crypto_int64) g0;
+ crypto_int64 f1g1_2 = f1_2 * (crypto_int64) g1;
+ crypto_int64 f1g2 = f1 * (crypto_int64) g2;
+ crypto_int64 f1g3_2 = f1_2 * (crypto_int64) g3;
+ crypto_int64 f1g4 = f1 * (crypto_int64) g4;
+ crypto_int64 f1g5_2 = f1_2 * (crypto_int64) g5;
+ crypto_int64 f1g6 = f1 * (crypto_int64) g6;
+ crypto_int64 f1g7_2 = f1_2 * (crypto_int64) g7;
+ crypto_int64 f1g8 = f1 * (crypto_int64) g8;
+ crypto_int64 f1g9_38 = f1_2 * (crypto_int64) g9_19;
+ crypto_int64 f2g0 = f2 * (crypto_int64) g0;
+ crypto_int64 f2g1 = f2 * (crypto_int64) g1;
+ crypto_int64 f2g2 = f2 * (crypto_int64) g2;
+ crypto_int64 f2g3 = f2 * (crypto_int64) g3;
+ crypto_int64 f2g4 = f2 * (crypto_int64) g4;
+ crypto_int64 f2g5 = f2 * (crypto_int64) g5;
+ crypto_int64 f2g6 = f2 * (crypto_int64) g6;
+ crypto_int64 f2g7 = f2 * (crypto_int64) g7;
+ crypto_int64 f2g8_19 = f2 * (crypto_int64) g8_19;
+ crypto_int64 f2g9_19 = f2 * (crypto_int64) g9_19;
+ crypto_int64 f3g0 = f3 * (crypto_int64) g0;
+ crypto_int64 f3g1_2 = f3_2 * (crypto_int64) g1;
+ crypto_int64 f3g2 = f3 * (crypto_int64) g2;
+ crypto_int64 f3g3_2 = f3_2 * (crypto_int64) g3;
+ crypto_int64 f3g4 = f3 * (crypto_int64) g4;
+ crypto_int64 f3g5_2 = f3_2 * (crypto_int64) g5;
+ crypto_int64 f3g6 = f3 * (crypto_int64) g6;
+ crypto_int64 f3g7_38 = f3_2 * (crypto_int64) g7_19;
+ crypto_int64 f3g8_19 = f3 * (crypto_int64) g8_19;
+ crypto_int64 f3g9_38 = f3_2 * (crypto_int64) g9_19;
+ crypto_int64 f4g0 = f4 * (crypto_int64) g0;
+ crypto_int64 f4g1 = f4 * (crypto_int64) g1;
+ crypto_int64 f4g2 = f4 * (crypto_int64) g2;
+ crypto_int64 f4g3 = f4 * (crypto_int64) g3;
+ crypto_int64 f4g4 = f4 * (crypto_int64) g4;
+ crypto_int64 f4g5 = f4 * (crypto_int64) g5;
+ crypto_int64 f4g6_19 = f4 * (crypto_int64) g6_19;
+ crypto_int64 f4g7_19 = f4 * (crypto_int64) g7_19;
+ crypto_int64 f4g8_19 = f4 * (crypto_int64) g8_19;
+ crypto_int64 f4g9_19 = f4 * (crypto_int64) g9_19;
+ crypto_int64 f5g0 = f5 * (crypto_int64) g0;
+ crypto_int64 f5g1_2 = f5_2 * (crypto_int64) g1;
+ crypto_int64 f5g2 = f5 * (crypto_int64) g2;
+ crypto_int64 f5g3_2 = f5_2 * (crypto_int64) g3;
+ crypto_int64 f5g4 = f5 * (crypto_int64) g4;
+ crypto_int64 f5g5_38 = f5_2 * (crypto_int64) g5_19;
+ crypto_int64 f5g6_19 = f5 * (crypto_int64) g6_19;
+ crypto_int64 f5g7_38 = f5_2 * (crypto_int64) g7_19;
+ crypto_int64 f5g8_19 = f5 * (crypto_int64) g8_19;
+ crypto_int64 f5g9_38 = f5_2 * (crypto_int64) g9_19;
+ crypto_int64 f6g0 = f6 * (crypto_int64) g0;
+ crypto_int64 f6g1 = f6 * (crypto_int64) g1;
+ crypto_int64 f6g2 = f6 * (crypto_int64) g2;
+ crypto_int64 f6g3 = f6 * (crypto_int64) g3;
+ crypto_int64 f6g4_19 = f6 * (crypto_int64) g4_19;
+ crypto_int64 f6g5_19 = f6 * (crypto_int64) g5_19;
+ crypto_int64 f6g6_19 = f6 * (crypto_int64) g6_19;
+ crypto_int64 f6g7_19 = f6 * (crypto_int64) g7_19;
+ crypto_int64 f6g8_19 = f6 * (crypto_int64) g8_19;
+ crypto_int64 f6g9_19 = f6 * (crypto_int64) g9_19;
+ crypto_int64 f7g0 = f7 * (crypto_int64) g0;
+ crypto_int64 f7g1_2 = f7_2 * (crypto_int64) g1;
+ crypto_int64 f7g2 = f7 * (crypto_int64) g2;
+ crypto_int64 f7g3_38 = f7_2 * (crypto_int64) g3_19;
+ crypto_int64 f7g4_19 = f7 * (crypto_int64) g4_19;
+ crypto_int64 f7g5_38 = f7_2 * (crypto_int64) g5_19;
+ crypto_int64 f7g6_19 = f7 * (crypto_int64) g6_19;
+ crypto_int64 f7g7_38 = f7_2 * (crypto_int64) g7_19;
+ crypto_int64 f7g8_19 = f7 * (crypto_int64) g8_19;
+ crypto_int64 f7g9_38 = f7_2 * (crypto_int64) g9_19;
+ crypto_int64 f8g0 = f8 * (crypto_int64) g0;
+ crypto_int64 f8g1 = f8 * (crypto_int64) g1;
+ crypto_int64 f8g2_19 = f8 * (crypto_int64) g2_19;
+ crypto_int64 f8g3_19 = f8 * (crypto_int64) g3_19;
+ crypto_int64 f8g4_19 = f8 * (crypto_int64) g4_19;
+ crypto_int64 f8g5_19 = f8 * (crypto_int64) g5_19;
+ crypto_int64 f8g6_19 = f8 * (crypto_int64) g6_19;
+ crypto_int64 f8g7_19 = f8 * (crypto_int64) g7_19;
+ crypto_int64 f8g8_19 = f8 * (crypto_int64) g8_19;
+ crypto_int64 f8g9_19 = f8 * (crypto_int64) g9_19;
+ crypto_int64 f9g0 = f9 * (crypto_int64) g0;
+ crypto_int64 f9g1_38 = f9_2 * (crypto_int64) g1_19;
+ crypto_int64 f9g2_19 = f9 * (crypto_int64) g2_19;
+ crypto_int64 f9g3_38 = f9_2 * (crypto_int64) g3_19;
+ crypto_int64 f9g4_19 = f9 * (crypto_int64) g4_19;
+ crypto_int64 f9g5_38 = f9_2 * (crypto_int64) g5_19;
+ crypto_int64 f9g6_19 = f9 * (crypto_int64) g6_19;
+ crypto_int64 f9g7_38 = f9_2 * (crypto_int64) g7_19;
+ crypto_int64 f9g8_19 = f9 * (crypto_int64) g8_19;
+ crypto_int64 f9g9_38 = f9_2 * (crypto_int64) g9_19;
+ crypto_int64 h0 = f0g0+f1g9_38+f2g8_19+f3g7_38+f4g6_19+f5g5_38+f6g4_19+f7g3_38+f8g2_19+f9g1_38;
+ crypto_int64 h1 = f0g1+f1g0 +f2g9_19+f3g8_19+f4g7_19+f5g6_19+f6g5_19+f7g4_19+f8g3_19+f9g2_19;
+ crypto_int64 h2 = f0g2+f1g1_2 +f2g0 +f3g9_38+f4g8_19+f5g7_38+f6g6_19+f7g5_38+f8g4_19+f9g3_38;
+ crypto_int64 h3 = f0g3+f1g2 +f2g1 +f3g0 +f4g9_19+f5g8_19+f6g7_19+f7g6_19+f8g5_19+f9g4_19;
+ crypto_int64 h4 = f0g4+f1g3_2 +f2g2 +f3g1_2 +f4g0 +f5g9_38+f6g8_19+f7g7_38+f8g6_19+f9g5_38;
+ crypto_int64 h5 = f0g5+f1g4 +f2g3 +f3g2 +f4g1 +f5g0 +f6g9_19+f7g8_19+f8g7_19+f9g6_19;
+ crypto_int64 h6 = f0g6+f1g5_2 +f2g4 +f3g3_2 +f4g2 +f5g1_2 +f6g0 +f7g9_38+f8g8_19+f9g7_38;
+ crypto_int64 h7 = f0g7+f1g6 +f2g5 +f3g4 +f4g3 +f5g2 +f6g1 +f7g0 +f8g9_19+f9g8_19;
+ crypto_int64 h8 = f0g8+f1g7_2 +f2g6 +f3g5_2 +f4g4 +f5g3_2 +f6g2 +f7g1_2 +f8g0 +f9g9_38;
+ crypto_int64 h9 = f0g9+f1g8 +f2g7 +f3g6 +f4g5 +f5g4 +f6g3 +f7g2 +f8g1 +f9g0 ;
+ crypto_int64 carry0;
+ crypto_int64 carry1;
+ crypto_int64 carry2;
+ crypto_int64 carry3;
+ crypto_int64 carry4;
+ crypto_int64 carry5;
+ crypto_int64 carry6;
+ crypto_int64 carry7;
+ crypto_int64 carry8;
+ crypto_int64 carry9;
+
+ /*
+ |h0| <= (1.65*1.65*2^52*(1+19+19+19+19)+1.65*1.65*2^50*(38+38+38+38+38))
+ i.e. |h0| <= 1.4*2^60; narrower ranges for h2, h4, h6, h8
+ |h1| <= (1.65*1.65*2^51*(1+1+19+19+19+19+19+19+19+19))
+ i.e. |h1| <= 1.7*2^59; narrower ranges for h3, h5, h7, h9
+ */
+
+ carry0 = (h0 + (crypto_int64) (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
+ carry4 = (h4 + (crypto_int64) (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
+ /* |h0| <= 2^25 */
+ /* |h4| <= 2^25 */
+ /* |h1| <= 1.71*2^59 */
+ /* |h5| <= 1.71*2^59 */
+
+ carry1 = (h1 + (crypto_int64) (1<<24)) >> 25; h2 += carry1; h1 -= carry1 << 25;
+ carry5 = (h5 + (crypto_int64) (1<<24)) >> 25; h6 += carry5; h5 -= carry5 << 25;
+ /* |h1| <= 2^24; from now on fits into int32 */
+ /* |h5| <= 2^24; from now on fits into int32 */
+ /* |h2| <= 1.41*2^60 */
+ /* |h6| <= 1.41*2^60 */
+
+ carry2 = (h2 + (crypto_int64) (1<<25)) >> 26; h3 += carry2; h2 -= carry2 << 26;
+ carry6 = (h6 + (crypto_int64) (1<<25)) >> 26; h7 += carry6; h6 -= carry6 << 26;
+ /* |h2| <= 2^25; from now on fits into int32 unchanged */
+ /* |h6| <= 2^25; from now on fits into int32 unchanged */
+ /* |h3| <= 1.71*2^59 */
+ /* |h7| <= 1.71*2^59 */
+
+ carry3 = (h3 + (crypto_int64) (1<<24)) >> 25; h4 += carry3; h3 -= carry3 << 25;
+ carry7 = (h7 + (crypto_int64) (1<<24)) >> 25; h8 += carry7; h7 -= carry7 << 25;
+ /* |h3| <= 2^24; from now on fits into int32 unchanged */
+ /* |h7| <= 2^24; from now on fits into int32 unchanged */
+ /* |h4| <= 1.72*2^34 */
+ /* |h8| <= 1.41*2^60 */
+
+ carry4 = (h4 + (crypto_int64) (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
+ carry8 = (h8 + (crypto_int64) (1<<25)) >> 26; h9 += carry8; h8 -= carry8 << 26;
+ /* |h4| <= 2^25; from now on fits into int32 unchanged */
+ /* |h8| <= 2^25; from now on fits into int32 unchanged */
+ /* |h5| <= 1.01*2^24 */
+ /* |h9| <= 1.71*2^59 */
+
+ carry9 = (h9 + (crypto_int64) (1<<24)) >> 25; h0 += carry9 * 19; h9 -= carry9 << 25;
+ /* |h9| <= 2^24; from now on fits into int32 unchanged */
+ /* |h0| <= 1.1*2^39 */
+
+ carry0 = (h0 + (crypto_int64) (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
+ /* |h0| <= 2^25; from now on fits into int32 unchanged */
+ /* |h1| <= 1.01*2^24 */
+
+ h[0] = h0;
+ h[1] = h1;
+ h[2] = h2;
+ h[3] = h3;
+ h[4] = h4;
+ h[5] = h5;
+ h[6] = h6;
+ h[7] = h7;
+ h[8] = h8;
+ h[9] = h9;
+}
diff --git a/jni/ed25519/fe_neg.c b/jni/ed25519/fe_neg.c
new file mode 100644
index 00000000..2078ce52
--- /dev/null
+++ b/jni/ed25519/fe_neg.c
@@ -0,0 +1,45 @@
+#include "fe.h"
+
+/*
+h = -f
+
+Preconditions:
+ |f| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+
+Postconditions:
+ |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+*/
+
+void fe_neg(fe h,const fe f)
+{
+ crypto_int32 f0 = f[0];
+ crypto_int32 f1 = f[1];
+ crypto_int32 f2 = f[2];
+ crypto_int32 f3 = f[3];
+ crypto_int32 f4 = f[4];
+ crypto_int32 f5 = f[5];
+ crypto_int32 f6 = f[6];
+ crypto_int32 f7 = f[7];
+ crypto_int32 f8 = f[8];
+ crypto_int32 f9 = f[9];
+ crypto_int32 h0 = -f0;
+ crypto_int32 h1 = -f1;
+ crypto_int32 h2 = -f2;
+ crypto_int32 h3 = -f3;
+ crypto_int32 h4 = -f4;
+ crypto_int32 h5 = -f5;
+ crypto_int32 h6 = -f6;
+ crypto_int32 h7 = -f7;
+ crypto_int32 h8 = -f8;
+ crypto_int32 h9 = -f9;
+ h[0] = h0;
+ h[1] = h1;
+ h[2] = h2;
+ h[3] = h3;
+ h[4] = h4;
+ h[5] = h5;
+ h[6] = h6;
+ h[7] = h7;
+ h[8] = h8;
+ h[9] = h9;
+}
diff --git a/jni/ed25519/fe_pow22523.c b/jni/ed25519/fe_pow22523.c
new file mode 100644
index 00000000..56675a59
--- /dev/null
+++ b/jni/ed25519/fe_pow22523.c
@@ -0,0 +1,13 @@
+#include "fe.h"
+
+void fe_pow22523(fe out,const fe z)
+{
+ fe t0;
+ fe t1;
+ fe t2;
+ int i;
+
+#include "pow22523.h"
+
+ return;
+}
diff --git a/jni/ed25519/fe_sq.c b/jni/ed25519/fe_sq.c
new file mode 100644
index 00000000..8dd11984
--- /dev/null
+++ b/jni/ed25519/fe_sq.c
@@ -0,0 +1,149 @@
+#include "fe.h"
+#include "crypto_int64.h"
+
+/*
+h = f * f
+Can overlap h with f.
+
+Preconditions:
+ |f| bounded by 1.65*2^26,1.65*2^25,1.65*2^26,1.65*2^25,etc.
+
+Postconditions:
+ |h| bounded by 1.01*2^25,1.01*2^24,1.01*2^25,1.01*2^24,etc.
+*/
+
+/*
+See fe_mul.c for discussion of implementation strategy.
+*/
+
+void fe_sq(fe h,const fe f)
+{
+ crypto_int32 f0 = f[0];
+ crypto_int32 f1 = f[1];
+ crypto_int32 f2 = f[2];
+ crypto_int32 f3 = f[3];
+ crypto_int32 f4 = f[4];
+ crypto_int32 f5 = f[5];
+ crypto_int32 f6 = f[6];
+ crypto_int32 f7 = f[7];
+ crypto_int32 f8 = f[8];
+ crypto_int32 f9 = f[9];
+ crypto_int32 f0_2 = 2 * f0;
+ crypto_int32 f1_2 = 2 * f1;
+ crypto_int32 f2_2 = 2 * f2;
+ crypto_int32 f3_2 = 2 * f3;
+ crypto_int32 f4_2 = 2 * f4;
+ crypto_int32 f5_2 = 2 * f5;
+ crypto_int32 f6_2 = 2 * f6;
+ crypto_int32 f7_2 = 2 * f7;
+ crypto_int32 f5_38 = 38 * f5; /* 1.959375*2^30 */
+ crypto_int32 f6_19 = 19 * f6; /* 1.959375*2^30 */
+ crypto_int32 f7_38 = 38 * f7; /* 1.959375*2^30 */
+ crypto_int32 f8_19 = 19 * f8; /* 1.959375*2^30 */
+ crypto_int32 f9_38 = 38 * f9; /* 1.959375*2^30 */
+ crypto_int64 f0f0 = f0 * (crypto_int64) f0;
+ crypto_int64 f0f1_2 = f0_2 * (crypto_int64) f1;
+ crypto_int64 f0f2_2 = f0_2 * (crypto_int64) f2;
+ crypto_int64 f0f3_2 = f0_2 * (crypto_int64) f3;
+ crypto_int64 f0f4_2 = f0_2 * (crypto_int64) f4;
+ crypto_int64 f0f5_2 = f0_2 * (crypto_int64) f5;
+ crypto_int64 f0f6_2 = f0_2 * (crypto_int64) f6;
+ crypto_int64 f0f7_2 = f0_2 * (crypto_int64) f7;
+ crypto_int64 f0f8_2 = f0_2 * (crypto_int64) f8;
+ crypto_int64 f0f9_2 = f0_2 * (crypto_int64) f9;
+ crypto_int64 f1f1_2 = f1_2 * (crypto_int64) f1;
+ crypto_int64 f1f2_2 = f1_2 * (crypto_int64) f2;
+ crypto_int64 f1f3_4 = f1_2 * (crypto_int64) f3_2;
+ crypto_int64 f1f4_2 = f1_2 * (crypto_int64) f4;
+ crypto_int64 f1f5_4 = f1_2 * (crypto_int64) f5_2;
+ crypto_int64 f1f6_2 = f1_2 * (crypto_int64) f6;
+ crypto_int64 f1f7_4 = f1_2 * (crypto_int64) f7_2;
+ crypto_int64 f1f8_2 = f1_2 * (crypto_int64) f8;
+ crypto_int64 f1f9_76 = f1_2 * (crypto_int64) f9_38;
+ crypto_int64 f2f2 = f2 * (crypto_int64) f2;
+ crypto_int64 f2f3_2 = f2_2 * (crypto_int64) f3;
+ crypto_int64 f2f4_2 = f2_2 * (crypto_int64) f4;
+ crypto_int64 f2f5_2 = f2_2 * (crypto_int64) f5;
+ crypto_int64 f2f6_2 = f2_2 * (crypto_int64) f6;
+ crypto_int64 f2f7_2 = f2_2 * (crypto_int64) f7;
+ crypto_int64 f2f8_38 = f2_2 * (crypto_int64) f8_19;
+ crypto_int64 f2f9_38 = f2 * (crypto_int64) f9_38;
+ crypto_int64 f3f3_2 = f3_2 * (crypto_int64) f3;
+ crypto_int64 f3f4_2 = f3_2 * (crypto_int64) f4;
+ crypto_int64 f3f5_4 = f3_2 * (crypto_int64) f5_2;
+ crypto_int64 f3f6_2 = f3_2 * (crypto_int64) f6;
+ crypto_int64 f3f7_76 = f3_2 * (crypto_int64) f7_38;
+ crypto_int64 f3f8_38 = f3_2 * (crypto_int64) f8_19;
+ crypto_int64 f3f9_76 = f3_2 * (crypto_int64) f9_38;
+ crypto_int64 f4f4 = f4 * (crypto_int64) f4;
+ crypto_int64 f4f5_2 = f4_2 * (crypto_int64) f5;
+ crypto_int64 f4f6_38 = f4_2 * (crypto_int64) f6_19;
+ crypto_int64 f4f7_38 = f4 * (crypto_int64) f7_38;
+ crypto_int64 f4f8_38 = f4_2 * (crypto_int64) f8_19;
+ crypto_int64 f4f9_38 = f4 * (crypto_int64) f9_38;
+ crypto_int64 f5f5_38 = f5 * (crypto_int64) f5_38;
+ crypto_int64 f5f6_38 = f5_2 * (crypto_int64) f6_19;
+ crypto_int64 f5f7_76 = f5_2 * (crypto_int64) f7_38;
+ crypto_int64 f5f8_38 = f5_2 * (crypto_int64) f8_19;
+ crypto_int64 f5f9_76 = f5_2 * (crypto_int64) f9_38;
+ crypto_int64 f6f6_19 = f6 * (crypto_int64) f6_19;
+ crypto_int64 f6f7_38 = f6 * (crypto_int64) f7_38;
+ crypto_int64 f6f8_38 = f6_2 * (crypto_int64) f8_19;
+ crypto_int64 f6f9_38 = f6 * (crypto_int64) f9_38;
+ crypto_int64 f7f7_38 = f7 * (crypto_int64) f7_38;
+ crypto_int64 f7f8_38 = f7_2 * (crypto_int64) f8_19;
+ crypto_int64 f7f9_76 = f7_2 * (crypto_int64) f9_38;
+ crypto_int64 f8f8_19 = f8 * (crypto_int64) f8_19;
+ crypto_int64 f8f9_38 = f8 * (crypto_int64) f9_38;
+ crypto_int64 f9f9_38 = f9 * (crypto_int64) f9_38;
+ crypto_int64 h0 = f0f0 +f1f9_76+f2f8_38+f3f7_76+f4f6_38+f5f5_38;
+ crypto_int64 h1 = f0f1_2+f2f9_38+f3f8_38+f4f7_38+f5f6_38;
+ crypto_int64 h2 = f0f2_2+f1f1_2 +f3f9_76+f4f8_38+f5f7_76+f6f6_19;
+ crypto_int64 h3 = f0f3_2+f1f2_2 +f4f9_38+f5f8_38+f6f7_38;
+ crypto_int64 h4 = f0f4_2+f1f3_4 +f2f2 +f5f9_76+f6f8_38+f7f7_38;
+ crypto_int64 h5 = f0f5_2+f1f4_2 +f2f3_2 +f6f9_38+f7f8_38;
+ crypto_int64 h6 = f0f6_2+f1f5_4 +f2f4_2 +f3f3_2 +f7f9_76+f8f8_19;
+ crypto_int64 h7 = f0f7_2+f1f6_2 +f2f5_2 +f3f4_2 +f8f9_38;
+ crypto_int64 h8 = f0f8_2+f1f7_4 +f2f6_2 +f3f5_4 +f4f4 +f9f9_38;
+ crypto_int64 h9 = f0f9_2+f1f8_2 +f2f7_2 +f3f6_2 +f4f5_2;
+ crypto_int64 carry0;
+ crypto_int64 carry1;
+ crypto_int64 carry2;
+ crypto_int64 carry3;
+ crypto_int64 carry4;
+ crypto_int64 carry5;
+ crypto_int64 carry6;
+ crypto_int64 carry7;
+ crypto_int64 carry8;
+ crypto_int64 carry9;
+
+ carry0 = (h0 + (crypto_int64) (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
+ carry4 = (h4 + (crypto_int64) (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
+
+ carry1 = (h1 + (crypto_int64) (1<<24)) >> 25; h2 += carry1; h1 -= carry1 << 25;
+ carry5 = (h5 + (crypto_int64) (1<<24)) >> 25; h6 += carry5; h5 -= carry5 << 25;
+
+ carry2 = (h2 + (crypto_int64) (1<<25)) >> 26; h3 += carry2; h2 -= carry2 << 26;
+ carry6 = (h6 + (crypto_int64) (1<<25)) >> 26; h7 += carry6; h6 -= carry6 << 26;
+
+ carry3 = (h3 + (crypto_int64) (1<<24)) >> 25; h4 += carry3; h3 -= carry3 << 25;
+ carry7 = (h7 + (crypto_int64) (1<<24)) >> 25; h8 += carry7; h7 -= carry7 << 25;
+
+ carry4 = (h4 + (crypto_int64) (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
+ carry8 = (h8 + (crypto_int64) (1<<25)) >> 26; h9 += carry8; h8 -= carry8 << 26;
+
+ carry9 = (h9 + (crypto_int64) (1<<24)) >> 25; h0 += carry9 * 19; h9 -= carry9 << 25;
+
+ carry0 = (h0 + (crypto_int64) (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
+
+ h[0] = h0;
+ h[1] = h1;
+ h[2] = h2;
+ h[3] = h3;
+ h[4] = h4;
+ h[5] = h5;
+ h[6] = h6;
+ h[7] = h7;
+ h[8] = h8;
+ h[9] = h9;
+}
diff --git a/jni/ed25519/fe_sq2.c b/jni/ed25519/fe_sq2.c
new file mode 100644
index 00000000..026ed3aa
--- /dev/null
+++ b/jni/ed25519/fe_sq2.c
@@ -0,0 +1,160 @@
+#include "fe.h"
+#include "crypto_int64.h"
+
+/*
+h = 2 * f * f
+Can overlap h with f.
+
+Preconditions:
+ |f| bounded by 1.65*2^26,1.65*2^25,1.65*2^26,1.65*2^25,etc.
+
+Postconditions:
+ |h| bounded by 1.01*2^25,1.01*2^24,1.01*2^25,1.01*2^24,etc.
+*/
+
+/*
+See fe_mul.c for discussion of implementation strategy.
+*/
+
+void fe_sq2(fe h,const fe f)
+{
+ crypto_int32 f0 = f[0];
+ crypto_int32 f1 = f[1];
+ crypto_int32 f2 = f[2];
+ crypto_int32 f3 = f[3];
+ crypto_int32 f4 = f[4];
+ crypto_int32 f5 = f[5];
+ crypto_int32 f6 = f[6];
+ crypto_int32 f7 = f[7];
+ crypto_int32 f8 = f[8];
+ crypto_int32 f9 = f[9];
+ crypto_int32 f0_2 = 2 * f0;
+ crypto_int32 f1_2 = 2 * f1;
+ crypto_int32 f2_2 = 2 * f2;
+ crypto_int32 f3_2 = 2 * f3;
+ crypto_int32 f4_2 = 2 * f4;
+ crypto_int32 f5_2 = 2 * f5;
+ crypto_int32 f6_2 = 2 * f6;
+ crypto_int32 f7_2 = 2 * f7;
+ crypto_int32 f5_38 = 38 * f5; /* 1.959375*2^30 */
+ crypto_int32 f6_19 = 19 * f6; /* 1.959375*2^30 */
+ crypto_int32 f7_38 = 38 * f7; /* 1.959375*2^30 */
+ crypto_int32 f8_19 = 19 * f8; /* 1.959375*2^30 */
+ crypto_int32 f9_38 = 38 * f9; /* 1.959375*2^30 */
+ crypto_int64 f0f0 = f0 * (crypto_int64) f0;
+ crypto_int64 f0f1_2 = f0_2 * (crypto_int64) f1;
+ crypto_int64 f0f2_2 = f0_2 * (crypto_int64) f2;
+ crypto_int64 f0f3_2 = f0_2 * (crypto_int64) f3;
+ crypto_int64 f0f4_2 = f0_2 * (crypto_int64) f4;
+ crypto_int64 f0f5_2 = f0_2 * (crypto_int64) f5;
+ crypto_int64 f0f6_2 = f0_2 * (crypto_int64) f6;
+ crypto_int64 f0f7_2 = f0_2 * (crypto_int64) f7;
+ crypto_int64 f0f8_2 = f0_2 * (crypto_int64) f8;
+ crypto_int64 f0f9_2 = f0_2 * (crypto_int64) f9;
+ crypto_int64 f1f1_2 = f1_2 * (crypto_int64) f1;
+ crypto_int64 f1f2_2 = f1_2 * (crypto_int64) f2;
+ crypto_int64 f1f3_4 = f1_2 * (crypto_int64) f3_2;
+ crypto_int64 f1f4_2 = f1_2 * (crypto_int64) f4;
+ crypto_int64 f1f5_4 = f1_2 * (crypto_int64) f5_2;
+ crypto_int64 f1f6_2 = f1_2 * (crypto_int64) f6;
+ crypto_int64 f1f7_4 = f1_2 * (crypto_int64) f7_2;
+ crypto_int64 f1f8_2 = f1_2 * (crypto_int64) f8;
+ crypto_int64 f1f9_76 = f1_2 * (crypto_int64) f9_38;
+ crypto_int64 f2f2 = f2 * (crypto_int64) f2;
+ crypto_int64 f2f3_2 = f2_2 * (crypto_int64) f3;
+ crypto_int64 f2f4_2 = f2_2 * (crypto_int64) f4;
+ crypto_int64 f2f5_2 = f2_2 * (crypto_int64) f5;
+ crypto_int64 f2f6_2 = f2_2 * (crypto_int64) f6;
+ crypto_int64 f2f7_2 = f2_2 * (crypto_int64) f7;
+ crypto_int64 f2f8_38 = f2_2 * (crypto_int64) f8_19;
+ crypto_int64 f2f9_38 = f2 * (crypto_int64) f9_38;
+ crypto_int64 f3f3_2 = f3_2 * (crypto_int64) f3;
+ crypto_int64 f3f4_2 = f3_2 * (crypto_int64) f4;
+ crypto_int64 f3f5_4 = f3_2 * (crypto_int64) f5_2;
+ crypto_int64 f3f6_2 = f3_2 * (crypto_int64) f6;
+ crypto_int64 f3f7_76 = f3_2 * (crypto_int64) f7_38;
+ crypto_int64 f3f8_38 = f3_2 * (crypto_int64) f8_19;
+ crypto_int64 f3f9_76 = f3_2 * (crypto_int64) f9_38;
+ crypto_int64 f4f4 = f4 * (crypto_int64) f4;
+ crypto_int64 f4f5_2 = f4_2 * (crypto_int64) f5;
+ crypto_int64 f4f6_38 = f4_2 * (crypto_int64) f6_19;
+ crypto_int64 f4f7_38 = f4 * (crypto_int64) f7_38;
+ crypto_int64 f4f8_38 = f4_2 * (crypto_int64) f8_19;
+ crypto_int64 f4f9_38 = f4 * (crypto_int64) f9_38;
+ crypto_int64 f5f5_38 = f5 * (crypto_int64) f5_38;
+ crypto_int64 f5f6_38 = f5_2 * (crypto_int64) f6_19;
+ crypto_int64 f5f7_76 = f5_2 * (crypto_int64) f7_38;
+ crypto_int64 f5f8_38 = f5_2 * (crypto_int64) f8_19;
+ crypto_int64 f5f9_76 = f5_2 * (crypto_int64) f9_38;
+ crypto_int64 f6f6_19 = f6 * (crypto_int64) f6_19;
+ crypto_int64 f6f7_38 = f6 * (crypto_int64) f7_38;
+ crypto_int64 f6f8_38 = f6_2 * (crypto_int64) f8_19;
+ crypto_int64 f6f9_38 = f6 * (crypto_int64) f9_38;
+ crypto_int64 f7f7_38 = f7 * (crypto_int64) f7_38;
+ crypto_int64 f7f8_38 = f7_2 * (crypto_int64) f8_19;
+ crypto_int64 f7f9_76 = f7_2 * (crypto_int64) f9_38;
+ crypto_int64 f8f8_19 = f8 * (crypto_int64) f8_19;
+ crypto_int64 f8f9_38 = f8 * (crypto_int64) f9_38;
+ crypto_int64 f9f9_38 = f9 * (crypto_int64) f9_38;
+ crypto_int64 h0 = f0f0 +f1f9_76+f2f8_38+f3f7_76+f4f6_38+f5f5_38;
+ crypto_int64 h1 = f0f1_2+f2f9_38+f3f8_38+f4f7_38+f5f6_38;
+ crypto_int64 h2 = f0f2_2+f1f1_2 +f3f9_76+f4f8_38+f5f7_76+f6f6_19;
+ crypto_int64 h3 = f0f3_2+f1f2_2 +f4f9_38+f5f8_38+f6f7_38;
+ crypto_int64 h4 = f0f4_2+f1f3_4 +f2f2 +f5f9_76+f6f8_38+f7f7_38;
+ crypto_int64 h5 = f0f5_2+f1f4_2 +f2f3_2 +f6f9_38+f7f8_38;
+ crypto_int64 h6 = f0f6_2+f1f5_4 +f2f4_2 +f3f3_2 +f7f9_76+f8f8_19;
+ crypto_int64 h7 = f0f7_2+f1f6_2 +f2f5_2 +f3f4_2 +f8f9_38;
+ crypto_int64 h8 = f0f8_2+f1f7_4 +f2f6_2 +f3f5_4 +f4f4 +f9f9_38;
+ crypto_int64 h9 = f0f9_2+f1f8_2 +f2f7_2 +f3f6_2 +f4f5_2;
+ crypto_int64 carry0;
+ crypto_int64 carry1;
+ crypto_int64 carry2;
+ crypto_int64 carry3;
+ crypto_int64 carry4;
+ crypto_int64 carry5;
+ crypto_int64 carry6;
+ crypto_int64 carry7;
+ crypto_int64 carry8;
+ crypto_int64 carry9;
+
+ h0 += h0;
+ h1 += h1;
+ h2 += h2;
+ h3 += h3;
+ h4 += h4;
+ h5 += h5;
+ h6 += h6;
+ h7 += h7;
+ h8 += h8;
+ h9 += h9;
+
+ carry0 = (h0 + (crypto_int64) (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
+ carry4 = (h4 + (crypto_int64) (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
+
+ carry1 = (h1 + (crypto_int64) (1<<24)) >> 25; h2 += carry1; h1 -= carry1 << 25;
+ carry5 = (h5 + (crypto_int64) (1<<24)) >> 25; h6 += carry5; h5 -= carry5 << 25;
+
+ carry2 = (h2 + (crypto_int64) (1<<25)) >> 26; h3 += carry2; h2 -= carry2 << 26;
+ carry6 = (h6 + (crypto_int64) (1<<25)) >> 26; h7 += carry6; h6 -= carry6 << 26;
+
+ carry3 = (h3 + (crypto_int64) (1<<24)) >> 25; h4 += carry3; h3 -= carry3 << 25;
+ carry7 = (h7 + (crypto_int64) (1<<24)) >> 25; h8 += carry7; h7 -= carry7 << 25;
+
+ carry4 = (h4 + (crypto_int64) (1<<25)) >> 26; h5 += carry4; h4 -= carry4 << 26;
+ carry8 = (h8 + (crypto_int64) (1<<25)) >> 26; h9 += carry8; h8 -= carry8 << 26;
+
+ carry9 = (h9 + (crypto_int64) (1<<24)) >> 25; h0 += carry9 * 19; h9 -= carry9 << 25;
+
+ carry0 = (h0 + (crypto_int64) (1<<25)) >> 26; h1 += carry0; h0 -= carry0 << 26;
+
+ h[0] = h0;
+ h[1] = h1;
+ h[2] = h2;
+ h[3] = h3;
+ h[4] = h4;
+ h[5] = h5;
+ h[6] = h6;
+ h[7] = h7;
+ h[8] = h8;
+ h[9] = h9;
+}
diff --git a/jni/ed25519/fe_sub.c b/jni/ed25519/fe_sub.c
new file mode 100644
index 00000000..6e26b7df
--- /dev/null
+++ b/jni/ed25519/fe_sub.c
@@ -0,0 +1,57 @@
+#include "fe.h"
+
+/*
+h = f - g
+Can overlap h with f or g.
+
+Preconditions:
+ |f| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+ |g| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.
+
+Postconditions:
+ |h| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
+*/
+
+void fe_sub(fe h,const fe f,const fe g)
+{
+ crypto_int32 f0 = f[0];
+ crypto_int32 f1 = f[1];
+ crypto_int32 f2 = f[2];
+ crypto_int32 f3 = f[3];
+ crypto_int32 f4 = f[4];
+ crypto_int32 f5 = f[5];
+ crypto_int32 f6 = f[6];
+ crypto_int32 f7 = f[7];
+ crypto_int32 f8 = f[8];
+ crypto_int32 f9 = f[9];
+ crypto_int32 g0 = g[0];
+ crypto_int32 g1 = g[1];
+ crypto_int32 g2 = g[2];
+ crypto_int32 g3 = g[3];
+ crypto_int32 g4 = g[4];
+ crypto_int32 g5 = g[5];
+ crypto_int32 g6 = g[6];
+ crypto_int32 g7 = g[7];
+ crypto_int32 g8 = g[8];
+ crypto_int32 g9 = g[9];
+ crypto_int32 h0 = f0 - g0;
+ crypto_int32 h1 = f1 - g1;
+ crypto_int32 h2 = f2 - g2;
+ crypto_int32 h3 = f3 - g3;
+ crypto_int32 h4 = f4 - g4;
+ crypto_int32 h5 = f5 - g5;
+ crypto_int32 h6 = f6 - g6;
+ crypto_int32 h7 = f7 - g7;
+ crypto_int32 h8 = f8 - g8;
+ crypto_int32 h9 = f9 - g9;
+ h[0] = h0;
+ h[1] = h1;
+ h[2] = h2;
+ h[3] = h3;
+ h[4] = h4;
+ h[5] = h5;
+ h[6] = h6;
+ h[7] = h7;
+ h[8] = h8;
+ h[9] = h9;
+}
diff --git a/jni/ed25519/fe_tobytes.c b/jni/ed25519/fe_tobytes.c
new file mode 100644
index 00000000..0a63baf9
--- /dev/null
+++ b/jni/ed25519/fe_tobytes.c
@@ -0,0 +1,119 @@
+#include "fe.h"
+
+/*
+Preconditions:
+ |h| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
+
+Write p=2^255-19; q=floor(h/p).
+Basic claim: q = floor(2^(-255)(h + 19 2^(-25)h9 + 2^(-1))).
+
+Proof:
+ Have |h|<=p so |q|<=1 so |19^2 2^(-255) q|<1/4.
+ Also have |h-2^230 h9|<2^231 so |19 2^(-255)(h-2^230 h9)|<1/4.
+
+ Write y=2^(-1)-19^2 2^(-255)q-19 2^(-255)(h-2^230 h9).
+ Then 0<y<1.
+
+ Write r=h-pq.
+ Have 0<=r<=p-1=2^255-20.
+ Thus 0<=r+19(2^-255)r<r+19(2^-255)2^255<=2^255-1.
+
+ Write x=r+19(2^-255)r+y.
+ Then 0<x<2^255 so floor(2^(-255)x) = 0 so floor(q+2^(-255)x) = q.
+
+ Have q+2^(-255)x = 2^(-255)(h + 19 2^(-25) h9 + 2^(-1))
+ so floor(2^(-255)(h + 19 2^(-25) h9 + 2^(-1))) = q.
+*/
+
+void fe_tobytes(unsigned char *s,const fe h)
+{
+ crypto_int32 h0 = h[0];
+ crypto_int32 h1 = h[1];
+ crypto_int32 h2 = h[2];
+ crypto_int32 h3 = h[3];
+ crypto_int32 h4 = h[4];
+ crypto_int32 h5 = h[5];
+ crypto_int32 h6 = h[6];
+ crypto_int32 h7 = h[7];
+ crypto_int32 h8 = h[8];
+ crypto_int32 h9 = h[9];
+ crypto_int32 q;
+ crypto_int32 carry0;
+ crypto_int32 carry1;
+ crypto_int32 carry2;
+ crypto_int32 carry3;
+ crypto_int32 carry4;
+ crypto_int32 carry5;
+ crypto_int32 carry6;
+ crypto_int32 carry7;
+ crypto_int32 carry8;
+ crypto_int32 carry9;
+
+ q = (19 * h9 + (((crypto_int32) 1) << 24)) >> 25;
+ q = (h0 + q) >> 26;
+ q = (h1 + q) >> 25;
+ q = (h2 + q) >> 26;
+ q = (h3 + q) >> 25;
+ q = (h4 + q) >> 26;
+ q = (h5 + q) >> 25;
+ q = (h6 + q) >> 26;
+ q = (h7 + q) >> 25;
+ q = (h8 + q) >> 26;
+ q = (h9 + q) >> 25;
+
+ /* Goal: Output h-(2^255-19)q, which is between 0 and 2^255-20. */
+ h0 += 19 * q;
+ /* Goal: Output h-2^255 q, which is between 0 and 2^255-20. */
+
+ carry0 = h0 >> 26; h1 += carry0; h0 -= carry0 << 26;
+ carry1 = h1 >> 25; h2 += carry1; h1 -= carry1 << 25;
+ carry2 = h2 >> 26; h3 += carry2; h2 -= carry2 << 26;
+ carry3 = h3 >> 25; h4 += carry3; h3 -= carry3 << 25;
+ carry4 = h4 >> 26; h5 += carry4; h4 -= carry4 << 26;
+ carry5 = h5 >> 25; h6 += carry5; h5 -= carry5 << 25;
+ carry6 = h6 >> 26; h7 += carry6; h6 -= carry6 << 26;
+ carry7 = h7 >> 25; h8 += carry7; h7 -= carry7 << 25;
+ carry8 = h8 >> 26; h9 += carry8; h8 -= carry8 << 26;
+ carry9 = h9 >> 25; h9 -= carry9 << 25;
+ /* h10 = carry9 */
+
+ /*
+ Goal: Output h0+...+2^255 h10-2^255 q, which is between 0 and 2^255-20.
+ Have h0+...+2^230 h9 between 0 and 2^255-1;
+ evidently 2^255 h10-2^255 q = 0.
+ Goal: Output h0+...+2^230 h9.
+ */
+
+ s[0] = h0 >> 0;
+ s[1] = h0 >> 8;
+ s[2] = h0 >> 16;
+ s[3] = (h0 >> 24) | (h1 << 2);
+ s[4] = h1 >> 6;
+ s[5] = h1 >> 14;
+ s[6] = (h1 >> 22) | (h2 << 3);
+ s[7] = h2 >> 5;
+ s[8] = h2 >> 13;
+ s[9] = (h2 >> 21) | (h3 << 5);
+ s[10] = h3 >> 3;
+ s[11] = h3 >> 11;
+ s[12] = (h3 >> 19) | (h4 << 6);
+ s[13] = h4 >> 2;
+ s[14] = h4 >> 10;
+ s[15] = h4 >> 18;
+ s[16] = h5 >> 0;
+ s[17] = h5 >> 8;
+ s[18] = h5 >> 16;
+ s[19] = (h5 >> 24) | (h6 << 1);
+ s[20] = h6 >> 7;
+ s[21] = h6 >> 15;
+ s[22] = (h6 >> 23) | (h7 << 3);
+ s[23] = h7 >> 5;
+ s[24] = h7 >> 13;
+ s[25] = (h7 >> 21) | (h8 << 4);
+ s[26] = h8 >> 4;
+ s[27] = h8 >> 12;
+ s[28] = (h8 >> 20) | (h9 << 6);
+ s[29] = h9 >> 2;
+ s[30] = h9 >> 10;
+ s[31] = h9 >> 18;
+}
diff --git a/jni/ed25519/ge.h b/jni/ed25519/ge.h
new file mode 100644
index 00000000..55e95f95
--- /dev/null
+++ b/jni/ed25519/ge.h
@@ -0,0 +1,95 @@
+#ifndef GE_H
+#define GE_H
+
+/*
+ge means group element.
+
+Here the group is the set of pairs (x,y) of field elements (see fe.h)
+satisfying -x^2 + y^2 = 1 + d x^2y^2
+where d = -121665/121666.
+
+Representations:
+ ge_p2 (projective): (X:Y:Z) satisfying x=X/Z, y=Y/Z
+ ge_p3 (extended): (X:Y:Z:T) satisfying x=X/Z, y=Y/Z, XY=ZT
+ ge_p1p1 (completed): ((X:Z),(Y:T)) satisfying x=X/Z, y=Y/T
+ ge_precomp (Duif): (y+x,y-x,2dxy)
+*/
+
+#include "fe.h"
+
+typedef struct {
+ fe X;
+ fe Y;
+ fe Z;
+} ge_p2;
+
+typedef struct {
+ fe X;
+ fe Y;
+ fe Z;
+ fe T;
+} ge_p3;
+
+typedef struct {
+ fe X;
+ fe Y;
+ fe Z;
+ fe T;
+} ge_p1p1;
+
+typedef struct {
+ fe yplusx;
+ fe yminusx;
+ fe xy2d;
+} ge_precomp;
+
+typedef struct {
+ fe YplusX;
+ fe YminusX;
+ fe Z;
+ fe T2d;
+} ge_cached;
+
+#define ge_frombytes_negate_vartime crypto_sign_ed25519_ref10_ge_frombytes_negate_vartime
+#define ge_tobytes crypto_sign_ed25519_ref10_ge_tobytes
+#define ge_p3_tobytes crypto_sign_ed25519_ref10_ge_p3_tobytes
+
+#define ge_p2_0 crypto_sign_ed25519_ref10_ge_p2_0
+#define ge_p3_0 crypto_sign_ed25519_ref10_ge_p3_0
+#define ge_precomp_0 crypto_sign_ed25519_ref10_ge_precomp_0
+#define ge_p3_to_p2 crypto_sign_ed25519_ref10_ge_p3_to_p2
+#define ge_p3_to_cached crypto_sign_ed25519_ref10_ge_p3_to_cached
+#define ge_p1p1_to_p2 crypto_sign_ed25519_ref10_ge_p1p1_to_p2
+#define ge_p1p1_to_p3 crypto_sign_ed25519_ref10_ge_p1p1_to_p3
+#define ge_p2_dbl crypto_sign_ed25519_ref10_ge_p2_dbl
+#define ge_p3_dbl crypto_sign_ed25519_ref10_ge_p3_dbl
+
+#define ge_madd crypto_sign_ed25519_ref10_ge_madd
+#define ge_msub crypto_sign_ed25519_ref10_ge_msub
+#define ge_add crypto_sign_ed25519_ref10_ge_add
+#define ge_sub crypto_sign_ed25519_ref10_ge_sub
+#define ge_scalarmult_base crypto_sign_ed25519_ref10_ge_scalarmult_base
+#define ge_double_scalarmult_vartime crypto_sign_ed25519_ref10_ge_double_scalarmult_vartime
+
+extern void ge_tobytes(unsigned char *,const ge_p2 *);
+extern void ge_p3_tobytes(unsigned char *,const ge_p3 *);
+extern int ge_frombytes_negate_vartime(ge_p3 *,const unsigned char *);
+
+extern void ge_p2_0(ge_p2 *);
+extern void ge_p3_0(ge_p3 *);
+extern void ge_precomp_0(ge_precomp *);
+extern void ge_p3_to_p2(ge_p2 *,const ge_p3 *);
+extern void ge_p3_to_cached(ge_cached *,const ge_p3 *);
+extern void ge_p1p1_to_p2(ge_p2 *,const ge_p1p1 *);
+extern void ge_p1p1_to_p3(ge_p3 *,const ge_p1p1 *);
+extern void ge_p2_dbl(ge_p1p1 *,const ge_p2 *);
+extern void ge_p3_dbl(ge_p1p1 *,const ge_p3 *);
+
+extern void ge_madd(ge_p1p1 *,const ge_p3 *,const ge_precomp *);
+extern void ge_msub(ge_p1p1 *,const ge_p3 *,const ge_precomp *);
+extern void ge_add(ge_p1p1 *,const ge_p3 *,const ge_cached *);
+extern void ge_sub(ge_p1p1 *,const ge_p3 *,const ge_cached *);
+extern void ge_scalarmult_base(ge_p3 *,const unsigned char *);
+extern void ge_double_scalarmult_vartime(ge_p2 *,const unsigned char *,const ge_p3 *,const unsigned char *);
+
+#endif
diff --git a/jni/ed25519/ge_add.c b/jni/ed25519/ge_add.c
new file mode 100644
index 00000000..da7ff5d2
--- /dev/null
+++ b/jni/ed25519/ge_add.c
@@ -0,0 +1,11 @@
+#include "ge.h"
+
+/*
+r = p + q
+*/
+
+void ge_add(ge_p1p1 *r,const ge_p3 *p,const ge_cached *q)
+{
+ fe t0;
+#include "ge_add.h"
+}
diff --git a/jni/ed25519/ge_add.h b/jni/ed25519/ge_add.h
new file mode 100644
index 00000000..7481f8ff
--- /dev/null
+++ b/jni/ed25519/ge_add.h
@@ -0,0 +1,97 @@
+
+/* qhasm: enter ge_add */
+
+/* qhasm: fe X1 */
+
+/* qhasm: fe Y1 */
+
+/* qhasm: fe Z1 */
+
+/* qhasm: fe Z2 */
+
+/* qhasm: fe T1 */
+
+/* qhasm: fe ZZ */
+
+/* qhasm: fe YpX2 */
+
+/* qhasm: fe YmX2 */
+
+/* qhasm: fe T2d2 */
+
+/* qhasm: fe X3 */
+
+/* qhasm: fe Y3 */
+
+/* qhasm: fe Z3 */
+
+/* qhasm: fe T3 */
+
+/* qhasm: fe YpX1 */
+
+/* qhasm: fe YmX1 */
+
+/* qhasm: fe A */
+
+/* qhasm: fe B */
+
+/* qhasm: fe C */
+
+/* qhasm: fe D */
+
+/* qhasm: YpX1 = Y1+X1 */
+/* asm 1: fe_add(>YpX1=fe#1,<Y1=fe#12,<X1=fe#11); */
+/* asm 2: fe_add(>YpX1=r->X,<Y1=p->Y,<X1=p->X); */
+fe_add(r->X,p->Y,p->X);
+
+/* qhasm: YmX1 = Y1-X1 */
+/* asm 1: fe_sub(>YmX1=fe#2,<Y1=fe#12,<X1=fe#11); */
+/* asm 2: fe_sub(>YmX1=r->Y,<Y1=p->Y,<X1=p->X); */
+fe_sub(r->Y,p->Y,p->X);
+
+/* qhasm: A = YpX1*YpX2 */
+/* asm 1: fe_mul(>A=fe#3,<YpX1=fe#1,<YpX2=fe#15); */
+/* asm 2: fe_mul(>A=r->Z,<YpX1=r->X,<YpX2=q->YplusX); */
+fe_mul(r->Z,r->X,q->YplusX);
+
+/* qhasm: B = YmX1*YmX2 */
+/* asm 1: fe_mul(>B=fe#2,<YmX1=fe#2,<YmX2=fe#16); */
+/* asm 2: fe_mul(>B=r->Y,<YmX1=r->Y,<YmX2=q->YminusX); */
+fe_mul(r->Y,r->Y,q->YminusX);
+
+/* qhasm: C = T2d2*T1 */
+/* asm 1: fe_mul(>C=fe#4,<T2d2=fe#18,<T1=fe#14); */
+/* asm 2: fe_mul(>C=r->T,<T2d2=q->T2d,<T1=p->T); */
+fe_mul(r->T,q->T2d,p->T);
+
+/* qhasm: ZZ = Z1*Z2 */
+/* asm 1: fe_mul(>ZZ=fe#1,<Z1=fe#13,<Z2=fe#17); */
+/* asm 2: fe_mul(>ZZ=r->X,<Z1=p->Z,<Z2=q->Z); */
+fe_mul(r->X,p->Z,q->Z);
+
+/* qhasm: D = 2*ZZ */
+/* asm 1: fe_add(>D=fe#5,<ZZ=fe#1,<ZZ=fe#1); */
+/* asm 2: fe_add(>D=t0,<ZZ=r->X,<ZZ=r->X); */
+fe_add(t0,r->X,r->X);
+
+/* qhasm: X3 = A-B */
+/* asm 1: fe_sub(>X3=fe#1,<A=fe#3,<B=fe#2); */
+/* asm 2: fe_sub(>X3=r->X,<A=r->Z,<B=r->Y); */
+fe_sub(r->X,r->Z,r->Y);
+
+/* qhasm: Y3 = A+B */
+/* asm 1: fe_add(>Y3=fe#2,<A=fe#3,<B=fe#2); */
+/* asm 2: fe_add(>Y3=r->Y,<A=r->Z,<B=r->Y); */
+fe_add(r->Y,r->Z,r->Y);
+
+/* qhasm: Z3 = D+C */
+/* asm 1: fe_add(>Z3=fe#3,<D=fe#5,<C=fe#4); */
+/* asm 2: fe_add(>Z3=r->Z,<D=t0,<C=r->T); */
+fe_add(r->Z,t0,r->T);
+
+/* qhasm: T3 = D-C */
+/* asm 1: fe_sub(>T3=fe#4,<D=fe#5,<C=fe#4); */
+/* asm 2: fe_sub(>T3=r->T,<D=t0,<C=r->T); */
+fe_sub(r->T,t0,r->T);
+
+/* qhasm: return */
diff --git a/jni/ed25519/ge_double_scalarmult.c b/jni/ed25519/ge_double_scalarmult.c
new file mode 100644
index 00000000..f8bf4bf7
--- /dev/null
+++ b/jni/ed25519/ge_double_scalarmult.c
@@ -0,0 +1,96 @@
+#include "ge.h"
+
+static void slide(signed char *r,const unsigned char *a)
+{
+ int i;
+ int b;
+ int k;
+
+ for (i = 0;i < 256;++i)
+ r[i] = 1 & (a[i >> 3] >> (i & 7));
+
+ for (i = 0;i < 256;++i)
+ if (r[i]) {
+ for (b = 1;b <= 6 && i + b < 256;++b) {
+ if (r[i + b]) {
+ if (r[i] + (r[i + b] << b) <= 15) {
+ r[i] += r[i + b] << b; r[i + b] = 0;
+ } else if (r[i] - (r[i + b] << b) >= -15) {
+ r[i] -= r[i + b] << b;
+ for (k = i + b;k < 256;++k) {
+ if (!r[k]) {
+ r[k] = 1;
+ break;
+ }
+ r[k] = 0;
+ }
+ } else
+ break;
+ }
+ }
+ }
+
+}
+
+static ge_precomp Bi[8] = {
+#include "base2.h"
+} ;
+
+/*
+r = a * A + b * B
+where a = a[0]+256*a[1]+...+256^31 a[31].
+and b = b[0]+256*b[1]+...+256^31 b[31].
+B is the Ed25519 base point (x,4/5) with x positive.
+*/
+
+void ge_double_scalarmult_vartime(ge_p2 *r,const unsigned char *a,const ge_p3 *A,const unsigned char *b)
+{
+ signed char aslide[256];
+ signed char bslide[256];
+ ge_cached Ai[8]; /* A,3A,5A,7A,9A,11A,13A,15A */
+ ge_p1p1 t;
+ ge_p3 u;
+ ge_p3 A2;
+ int i;
+
+ slide(aslide,a);
+ slide(bslide,b);
+
+ ge_p3_to_cached(&Ai[0],A);
+ ge_p3_dbl(&t,A); ge_p1p1_to_p3(&A2,&t);
+ ge_add(&t,&A2,&Ai[0]); ge_p1p1_to_p3(&u,&t); ge_p3_to_cached(&Ai[1],&u);
+ ge_add(&t,&A2,&Ai[1]); ge_p1p1_to_p3(&u,&t); ge_p3_to_cached(&Ai[2],&u);
+ ge_add(&t,&A2,&Ai[2]); ge_p1p1_to_p3(&u,&t); ge_p3_to_cached(&Ai[3],&u);
+ ge_add(&t,&A2,&Ai[3]); ge_p1p1_to_p3(&u,&t); ge_p3_to_cached(&Ai[4],&u);
+ ge_add(&t,&A2,&Ai[4]); ge_p1p1_to_p3(&u,&t); ge_p3_to_cached(&Ai[5],&u);
+ ge_add(&t,&A2,&Ai[5]); ge_p1p1_to_p3(&u,&t); ge_p3_to_cached(&Ai[6],&u);
+ ge_add(&t,&A2,&Ai[6]); ge_p1p1_to_p3(&u,&t); ge_p3_to_cached(&Ai[7],&u);
+
+ ge_p2_0(r);
+
+ for (i = 255;i >= 0;--i) {
+ if (aslide[i] || bslide[i]) break;
+ }
+
+ for (;i >= 0;--i) {
+ ge_p2_dbl(&t,r);
+
+ if (aslide[i] > 0) {
+ ge_p1p1_to_p3(&u,&t);
+ ge_add(&t,&u,&Ai[aslide[i]/2]);
+ } else if (aslide[i] < 0) {
+ ge_p1p1_to_p3(&u,&t);
+ ge_sub(&t,&u,&Ai[(-aslide[i])/2]);
+ }
+
+ if (bslide[i] > 0) {
+ ge_p1p1_to_p3(&u,&t);
+ ge_madd(&t,&u,&Bi[bslide[i]/2]);
+ } else if (bslide[i] < 0) {
+ ge_p1p1_to_p3(&u,&t);
+ ge_msub(&t,&u,&Bi[(-bslide[i])/2]);
+ }
+
+ ge_p1p1_to_p2(r,&t);
+ }
+}
diff --git a/jni/ed25519/ge_frombytes.c b/jni/ed25519/ge_frombytes.c
new file mode 100644
index 00000000..1a059ee9
--- /dev/null
+++ b/jni/ed25519/ge_frombytes.c
@@ -0,0 +1,50 @@
+#include "ge.h"
+
+static const fe d = {
+#include "d.h"
+} ;
+
+static const fe sqrtm1 = {
+#include "sqrtm1.h"
+} ;
+
+int ge_frombytes_negate_vartime(ge_p3 *h,const unsigned char *s)
+{
+ fe u;
+ fe v;
+ fe v3;
+ fe vxx;
+ fe check;
+
+ fe_frombytes(h->Y,s);
+ fe_1(h->Z);
+ fe_sq(u,h->Y);
+ fe_mul(v,u,d);
+ fe_sub(u,u,h->Z); /* u = y^2-1 */
+ fe_add(v,v,h->Z); /* v = dy^2+1 */
+
+ fe_sq(v3,v);
+ fe_mul(v3,v3,v); /* v3 = v^3 */
+ fe_sq(h->X,v3);
+ fe_mul(h->X,h->X,v);
+ fe_mul(h->X,h->X,u); /* x = uv^7 */
+
+ fe_pow22523(h->X,h->X); /* x = (uv^7)^((q-5)/8) */
+ fe_mul(h->X,h->X,v3);
+ fe_mul(h->X,h->X,u); /* x = uv^3(uv^7)^((q-5)/8) */
+
+ fe_sq(vxx,h->X);
+ fe_mul(vxx,vxx,v);
+ fe_sub(check,vxx,u); /* vx^2-u */
+ if (fe_isnonzero(check)) {
+ fe_add(check,vxx,u); /* vx^2+u */
+ if (fe_isnonzero(check)) return -1;
+ fe_mul(h->X,h->X,sqrtm1);
+ }
+
+ if (fe_isnegative(h->X) == (s[31] >> 7))
+ fe_neg(h->X,h->X);
+
+ fe_mul(h->T,h->X,h->Y);
+ return 0;
+}
diff --git a/jni/ed25519/ge_madd.c b/jni/ed25519/ge_madd.c
new file mode 100644
index 00000000..62257177
--- /dev/null
+++ b/jni/ed25519/ge_madd.c
@@ -0,0 +1,11 @@
+#include "ge.h"
+
+/*
+r = p + q
+*/
+
+void ge_madd(ge_p1p1 *r,const ge_p3 *p,const ge_precomp *q)
+{
+ fe t0;
+#include "ge_madd.h"
+}
diff --git a/jni/ed25519/ge_madd.h b/jni/ed25519/ge_madd.h
new file mode 100644
index 00000000..ecae8495
--- /dev/null
+++ b/jni/ed25519/ge_madd.h
@@ -0,0 +1,88 @@
+
+/* qhasm: enter ge_madd */
+
+/* qhasm: fe X1 */
+
+/* qhasm: fe Y1 */
+
+/* qhasm: fe Z1 */
+
+/* qhasm: fe T1 */
+
+/* qhasm: fe ypx2 */
+
+/* qhasm: fe ymx2 */
+
+/* qhasm: fe xy2d2 */
+
+/* qhasm: fe X3 */
+
+/* qhasm: fe Y3 */
+
+/* qhasm: fe Z3 */
+
+/* qhasm: fe T3 */
+
+/* qhasm: fe YpX1 */
+
+/* qhasm: fe YmX1 */
+
+/* qhasm: fe A */
+
+/* qhasm: fe B */
+
+/* qhasm: fe C */
+
+/* qhasm: fe D */
+
+/* qhasm: YpX1 = Y1+X1 */
+/* asm 1: fe_add(>YpX1=fe#1,<Y1=fe#12,<X1=fe#11); */
+/* asm 2: fe_add(>YpX1=r->X,<Y1=p->Y,<X1=p->X); */
+fe_add(r->X,p->Y,p->X);
+
+/* qhasm: YmX1 = Y1-X1 */
+/* asm 1: fe_sub(>YmX1=fe#2,<Y1=fe#12,<X1=fe#11); */
+/* asm 2: fe_sub(>YmX1=r->Y,<Y1=p->Y,<X1=p->X); */
+fe_sub(r->Y,p->Y,p->X);
+
+/* qhasm: A = YpX1*ypx2 */
+/* asm 1: fe_mul(>A=fe#3,<YpX1=fe#1,<ypx2=fe#15); */
+/* asm 2: fe_mul(>A=r->Z,<YpX1=r->X,<ypx2=q->yplusx); */
+fe_mul(r->Z,r->X,q->yplusx);
+
+/* qhasm: B = YmX1*ymx2 */
+/* asm 1: fe_mul(>B=fe#2,<YmX1=fe#2,<ymx2=fe#16); */
+/* asm 2: fe_mul(>B=r->Y,<YmX1=r->Y,<ymx2=q->yminusx); */
+fe_mul(r->Y,r->Y,q->yminusx);
+
+/* qhasm: C = xy2d2*T1 */
+/* asm 1: fe_mul(>C=fe#4,<xy2d2=fe#17,<T1=fe#14); */
+/* asm 2: fe_mul(>C=r->T,<xy2d2=q->xy2d,<T1=p->T); */
+fe_mul(r->T,q->xy2d,p->T);
+
+/* qhasm: D = 2*Z1 */
+/* asm 1: fe_add(>D=fe#5,<Z1=fe#13,<Z1=fe#13); */
+/* asm 2: fe_add(>D=t0,<Z1=p->Z,<Z1=p->Z); */
+fe_add(t0,p->Z,p->Z);
+
+/* qhasm: X3 = A-B */
+/* asm 1: fe_sub(>X3=fe#1,<A=fe#3,<B=fe#2); */
+/* asm 2: fe_sub(>X3=r->X,<A=r->Z,<B=r->Y); */
+fe_sub(r->X,r->Z,r->Y);
+
+/* qhasm: Y3 = A+B */
+/* asm 1: fe_add(>Y3=fe#2,<A=fe#3,<B=fe#2); */
+/* asm 2: fe_add(>Y3=r->Y,<A=r->Z,<B=r->Y); */
+fe_add(r->Y,r->Z,r->Y);
+
+/* qhasm: Z3 = D+C */
+/* asm 1: fe_add(>Z3=fe#3,<D=fe#5,<C=fe#4); */
+/* asm 2: fe_add(>Z3=r->Z,<D=t0,<C=r->T); */
+fe_add(r->Z,t0,r->T);
+
+/* qhasm: T3 = D-C */
+/* asm 1: fe_sub(>T3=fe#4,<D=fe#5,<C=fe#4); */
+/* asm 2: fe_sub(>T3=r->T,<D=t0,<C=r->T); */
+fe_sub(r->T,t0,r->T);
+
+/* qhasm: return */
diff --git a/jni/ed25519/ge_msub.c b/jni/ed25519/ge_msub.c
new file mode 100644
index 00000000..741ecbf1
--- /dev/null
+++ b/jni/ed25519/ge_msub.c
@@ -0,0 +1,11 @@
+#include "ge.h"
+
+/*
+r = p - q
+*/
+
+void ge_msub(ge_p1p1 *r,const ge_p3 *p,const ge_precomp *q)
+{
+ fe t0;
+#include "ge_msub.h"
+}
diff --git a/jni/ed25519/ge_msub.h b/jni/ed25519/ge_msub.h
new file mode 100644
index 00000000..500f986b
--- /dev/null
+++ b/jni/ed25519/ge_msub.h
@@ -0,0 +1,88 @@
+
+/* qhasm: enter ge_msub */
+
+/* qhasm: fe X1 */
+
+/* qhasm: fe Y1 */
+
+/* qhasm: fe Z1 */
+
+/* qhasm: fe T1 */
+
+/* qhasm: fe ypx2 */
+
+/* qhasm: fe ymx2 */
+
+/* qhasm: fe xy2d2 */
+
+/* qhasm: fe X3 */
+
+/* qhasm: fe Y3 */
+
+/* qhasm: fe Z3 */
+
+/* qhasm: fe T3 */
+
+/* qhasm: fe YpX1 */
+
+/* qhasm: fe YmX1 */
+
+/* qhasm: fe A */
+
+/* qhasm: fe B */
+
+/* qhasm: fe C */
+
+/* qhasm: fe D */
+
+/* qhasm: YpX1 = Y1+X1 */
+/* asm 1: fe_add(>YpX1=fe#1,<Y1=fe#12,<X1=fe#11); */
+/* asm 2: fe_add(>YpX1=r->X,<Y1=p->Y,<X1=p->X); */
+fe_add(r->X,p->Y,p->X);
+
+/* qhasm: YmX1 = Y1-X1 */
+/* asm 1: fe_sub(>YmX1=fe#2,<Y1=fe#12,<X1=fe#11); */
+/* asm 2: fe_sub(>YmX1=r->Y,<Y1=p->Y,<X1=p->X); */
+fe_sub(r->Y,p->Y,p->X);
+
+/* qhasm: A = YpX1*ymx2 */
+/* asm 1: fe_mul(>A=fe#3,<YpX1=fe#1,<ymx2=fe#16); */
+/* asm 2: fe_mul(>A=r->Z,<YpX1=r->X,<ymx2=q->yminusx); */
+fe_mul(r->Z,r->X,q->yminusx);
+
+/* qhasm: B = YmX1*ypx2 */
+/* asm 1: fe_mul(>B=fe#2,<YmX1=fe#2,<ypx2=fe#15); */
+/* asm 2: fe_mul(>B=r->Y,<YmX1=r->Y,<ypx2=q->yplusx); */
+fe_mul(r->Y,r->Y,q->yplusx);
+
+/* qhasm: C = xy2d2*T1 */
+/* asm 1: fe_mul(>C=fe#4,<xy2d2=fe#17,<T1=fe#14); */
+/* asm 2: fe_mul(>C=r->T,<xy2d2=q->xy2d,<T1=p->T); */
+fe_mul(r->T,q->xy2d,p->T);
+
+/* qhasm: D = 2*Z1 */
+/* asm 1: fe_add(>D=fe#5,<Z1=fe#13,<Z1=fe#13); */
+/* asm 2: fe_add(>D=t0,<Z1=p->Z,<Z1=p->Z); */
+fe_add(t0,p->Z,p->Z);
+
+/* qhasm: X3 = A-B */
+/* asm 1: fe_sub(>X3=fe#1,<A=fe#3,<B=fe#2); */
+/* asm 2: fe_sub(>X3=r->X,<A=r->Z,<B=r->Y); */
+fe_sub(r->X,r->Z,r->Y);
+
+/* qhasm: Y3 = A+B */
+/* asm 1: fe_add(>Y3=fe#2,<A=fe#3,<B=fe#2); */
+/* asm 2: fe_add(>Y3=r->Y,<A=r->Z,<B=r->Y); */
+fe_add(r->Y,r->Z,r->Y);
+
+/* qhasm: Z3 = D-C */
+/* asm 1: fe_sub(>Z3=fe#3,<D=fe#5,<C=fe#4); */
+/* asm 2: fe_sub(>Z3=r->Z,<D=t0,<C=r->T); */
+fe_sub(r->Z,t0,r->T);
+
+/* qhasm: T3 = D+C */
+/* asm 1: fe_add(>T3=fe#4,<D=fe#5,<C=fe#4); */
+/* asm 2: fe_add(>T3=r->T,<D=t0,<C=r->T); */
+fe_add(r->T,t0,r->T);
+
+/* qhasm: return */
diff --git a/jni/ed25519/ge_p1p1_to_p2.c b/jni/ed25519/ge_p1p1_to_p2.c
new file mode 100644
index 00000000..9bb5013d
--- /dev/null
+++ b/jni/ed25519/ge_p1p1_to_p2.c
@@ -0,0 +1,12 @@
+#include "ge.h"
+
+/*
+r = p
+*/
+
+extern void ge_p1p1_to_p2(ge_p2 *r,const ge_p1p1 *p)
+{
+ fe_mul(r->X,p->X,p->T);
+ fe_mul(r->Y,p->Y,p->Z);
+ fe_mul(r->Z,p->Z,p->T);
+}
diff --git a/jni/ed25519/ge_p1p1_to_p3.c b/jni/ed25519/ge_p1p1_to_p3.c
new file mode 100644
index 00000000..2f57b109
--- /dev/null
+++ b/jni/ed25519/ge_p1p1_to_p3.c
@@ -0,0 +1,13 @@
+#include "ge.h"
+
+/*
+r = p
+*/
+
+extern void ge_p1p1_to_p3(ge_p3 *r,const ge_p1p1 *p)
+{
+ fe_mul(r->X,p->X,p->T);
+ fe_mul(r->Y,p->Y,p->Z);
+ fe_mul(r->Z,p->Z,p->T);
+ fe_mul(r->T,p->X,p->Y);
+}
diff --git a/jni/ed25519/ge_p2_0.c b/jni/ed25519/ge_p2_0.c
new file mode 100644
index 00000000..6191d1e6
--- /dev/null
+++ b/jni/ed25519/ge_p2_0.c
@@ -0,0 +1,8 @@
+#include "ge.h"
+
+void ge_p2_0(ge_p2 *h)
+{
+ fe_0(h->X);
+ fe_1(h->Y);
+ fe_1(h->Z);
+}
diff --git a/jni/ed25519/ge_p2_dbl.c b/jni/ed25519/ge_p2_dbl.c
new file mode 100644
index 00000000..2e332b5c
--- /dev/null
+++ b/jni/ed25519/ge_p2_dbl.c
@@ -0,0 +1,11 @@
+#include "ge.h"
+
+/*
+r = 2 * p
+*/
+
+void ge_p2_dbl(ge_p1p1 *r,const ge_p2 *p)
+{
+ fe t0;
+#include "ge_p2_dbl.h"
+}
diff --git a/jni/ed25519/ge_p2_dbl.h b/jni/ed25519/ge_p2_dbl.h
new file mode 100644
index 00000000..128efed9
--- /dev/null
+++ b/jni/ed25519/ge_p2_dbl.h
@@ -0,0 +1,73 @@
+
+/* qhasm: enter ge_p2_dbl */
+
+/* qhasm: fe X1 */
+
+/* qhasm: fe Y1 */
+
+/* qhasm: fe Z1 */
+
+/* qhasm: fe A */
+
+/* qhasm: fe AA */
+
+/* qhasm: fe XX */
+
+/* qhasm: fe YY */
+
+/* qhasm: fe B */
+
+/* qhasm: fe X3 */
+
+/* qhasm: fe Y3 */
+
+/* qhasm: fe Z3 */
+
+/* qhasm: fe T3 */
+
+/* qhasm: XX=X1^2 */
+/* asm 1: fe_sq(>XX=fe#1,<X1=fe#11); */
+/* asm 2: fe_sq(>XX=r->X,<X1=p->X); */
+fe_sq(r->X,p->X);
+
+/* qhasm: YY=Y1^2 */
+/* asm 1: fe_sq(>YY=fe#3,<Y1=fe#12); */
+/* asm 2: fe_sq(>YY=r->Z,<Y1=p->Y); */
+fe_sq(r->Z,p->Y);
+
+/* qhasm: B=2*Z1^2 */
+/* asm 1: fe_sq2(>B=fe#4,<Z1=fe#13); */
+/* asm 2: fe_sq2(>B=r->T,<Z1=p->Z); */
+fe_sq2(r->T,p->Z);
+
+/* qhasm: A=X1+Y1 */
+/* asm 1: fe_add(>A=fe#2,<X1=fe#11,<Y1=fe#12); */
+/* asm 2: fe_add(>A=r->Y,<X1=p->X,<Y1=p->Y); */
+fe_add(r->Y,p->X,p->Y);
+
+/* qhasm: AA=A^2 */
+/* asm 1: fe_sq(>AA=fe#5,<A=fe#2); */
+/* asm 2: fe_sq(>AA=t0,<A=r->Y); */
+fe_sq(t0,r->Y);
+
+/* qhasm: Y3=YY+XX */
+/* asm 1: fe_add(>Y3=fe#2,<YY=fe#3,<XX=fe#1); */
+/* asm 2: fe_add(>Y3=r->Y,<YY=r->Z,<XX=r->X); */
+fe_add(r->Y,r->Z,r->X);
+
+/* qhasm: Z3=YY-XX */
+/* asm 1: fe_sub(>Z3=fe#3,<YY=fe#3,<XX=fe#1); */
+/* asm 2: fe_sub(>Z3=r->Z,<YY=r->Z,<XX=r->X); */
+fe_sub(r->Z,r->Z,r->X);
+
+/* qhasm: X3=AA-Y3 */
+/* asm 1: fe_sub(>X3=fe#1,<AA=fe#5,<Y3=fe#2); */
+/* asm 2: fe_sub(>X3=r->X,<AA=t0,<Y3=r->Y); */
+fe_sub(r->X,t0,r->Y);
+
+/* qhasm: T3=B-Z3 */
+/* asm 1: fe_sub(>T3=fe#4,<B=fe#4,<Z3=fe#3); */
+/* asm 2: fe_sub(>T3=r->T,<B=r->T,<Z3=r->Z); */
+fe_sub(r->T,r->T,r->Z);
+
+/* qhasm: return */
diff --git a/jni/ed25519/ge_p3_0.c b/jni/ed25519/ge_p3_0.c
new file mode 100644
index 00000000..401b2935
--- /dev/null
+++ b/jni/ed25519/ge_p3_0.c
@@ -0,0 +1,9 @@
+#include "ge.h"
+
+void ge_p3_0(ge_p3 *h)
+{
+ fe_0(h->X);
+ fe_1(h->Y);
+ fe_1(h->Z);
+ fe_0(h->T);
+}
diff --git a/jni/ed25519/ge_p3_dbl.c b/jni/ed25519/ge_p3_dbl.c
new file mode 100644
index 00000000..0d8a0591
--- /dev/null
+++ b/jni/ed25519/ge_p3_dbl.c
@@ -0,0 +1,12 @@
+#include "ge.h"
+
+/*
+r = 2 * p
+*/
+
+void ge_p3_dbl(ge_p1p1 *r,const ge_p3 *p)
+{
+ ge_p2 q;
+ ge_p3_to_p2(&q,p);
+ ge_p2_dbl(r,&q);
+}
diff --git a/jni/ed25519/ge_p3_to_cached.c b/jni/ed25519/ge_p3_to_cached.c
new file mode 100644
index 00000000..bde64228
--- /dev/null
+++ b/jni/ed25519/ge_p3_to_cached.c
@@ -0,0 +1,17 @@
+#include "ge.h"
+
+/*
+r = p
+*/
+
+static const fe d2 = {
+#include "d2.h"
+} ;
+
+extern void ge_p3_to_cached(ge_cached *r,const ge_p3 *p)
+{
+ fe_add(r->YplusX,p->Y,p->X);
+ fe_sub(r->YminusX,p->Y,p->X);
+ fe_copy(r->Z,p->Z);
+ fe_mul(r->T2d,p->T,d2);
+}
diff --git a/jni/ed25519/ge_p3_to_p2.c b/jni/ed25519/ge_p3_to_p2.c
new file mode 100644
index 00000000..e532a9e4
--- /dev/null
+++ b/jni/ed25519/ge_p3_to_p2.c
@@ -0,0 +1,12 @@
+#include "ge.h"
+
+/*
+r = p
+*/
+
+extern void ge_p3_to_p2(ge_p2 *r,const ge_p3 *p)
+{
+ fe_copy(r->X,p->X);
+ fe_copy(r->Y,p->Y);
+ fe_copy(r->Z,p->Z);
+}
diff --git a/jni/ed25519/ge_p3_tobytes.c b/jni/ed25519/ge_p3_tobytes.c
new file mode 100644
index 00000000..21cb2fc6
--- /dev/null
+++ b/jni/ed25519/ge_p3_tobytes.c
@@ -0,0 +1,14 @@
+#include "ge.h"
+
+void ge_p3_tobytes(unsigned char *s,const ge_p3 *h)
+{
+ fe recip;
+ fe x;
+ fe y;
+
+ fe_invert(recip,h->Z);
+ fe_mul(x,h->X,recip);
+ fe_mul(y,h->Y,recip);
+ fe_tobytes(s,y);
+ s[31] ^= fe_isnegative(x) << 7;
+}
diff --git a/jni/ed25519/ge_precomp_0.c b/jni/ed25519/ge_precomp_0.c
new file mode 100644
index 00000000..2e218861
--- /dev/null
+++ b/jni/ed25519/ge_precomp_0.c
@@ -0,0 +1,8 @@
+#include "ge.h"
+
+void ge_precomp_0(ge_precomp *h)
+{
+ fe_1(h->yplusx);
+ fe_1(h->yminusx);
+ fe_0(h->xy2d);
+}
diff --git a/jni/ed25519/ge_scalarmult_base.c b/jni/ed25519/ge_scalarmult_base.c
new file mode 100644
index 00000000..421e4fa0
--- /dev/null
+++ b/jni/ed25519/ge_scalarmult_base.c
@@ -0,0 +1,105 @@
+#include "ge.h"
+#include "crypto_uint32.h"
+
+static unsigned char equal(signed char b,signed char c)
+{
+ unsigned char ub = b;
+ unsigned char uc = c;
+ unsigned char x = ub ^ uc; /* 0: yes; 1..255: no */
+ crypto_uint32 y = x; /* 0: yes; 1..255: no */
+ y -= 1; /* 4294967295: yes; 0..254: no */
+ y >>= 31; /* 1: yes; 0: no */
+ return y;
+}
+
+static unsigned char negative(signed char b)
+{
+ unsigned long long x = b; /* 18446744073709551361..18446744073709551615: yes; 0..255: no */
+ x >>= 63; /* 1: yes; 0: no */
+ return x;
+}
+
+static void cmov(ge_precomp *t,ge_precomp *u,unsigned char b)
+{
+ fe_cmov(t->yplusx,u->yplusx,b);
+ fe_cmov(t->yminusx,u->yminusx,b);
+ fe_cmov(t->xy2d,u->xy2d,b);
+}
+
+/* base[i][j] = (j+1)*256^i*B */
+static ge_precomp base[32][8] = {
+#include "base.h"
+} ;
+
+static void select(ge_precomp *t,int pos,signed char b)
+{
+ ge_precomp minust;
+ unsigned char bnegative = negative(b);
+ unsigned char babs = b - (((-bnegative) & b) << 1);
+
+ ge_precomp_0(t);
+ cmov(t,&base[pos][0],equal(babs,1));
+ cmov(t,&base[pos][1],equal(babs,2));
+ cmov(t,&base[pos][2],equal(babs,3));
+ cmov(t,&base[pos][3],equal(babs,4));
+ cmov(t,&base[pos][4],equal(babs,5));
+ cmov(t,&base[pos][5],equal(babs,6));
+ cmov(t,&base[pos][6],equal(babs,7));
+ cmov(t,&base[pos][7],equal(babs,8));
+ fe_copy(minust.yplusx,t->yminusx);
+ fe_copy(minust.yminusx,t->yplusx);
+ fe_neg(minust.xy2d,t->xy2d);
+ cmov(t,&minust,bnegative);
+}
+
+/*
+h = a * B
+where a = a[0]+256*a[1]+...+256^31 a[31]
+B is the Ed25519 base point (x,4/5) with x positive.
+
+Preconditions:
+ a[31] <= 127
+*/
+
+void ge_scalarmult_base(ge_p3 *h,const unsigned char *a)
+{
+ signed char e[64];
+ signed char carry;
+ ge_p1p1 r;
+ ge_p2 s;
+ ge_precomp t;
+ int i;
+
+ for (i = 0;i < 32;++i) {
+ e[2 * i + 0] = (a[i] >> 0) & 15;
+ e[2 * i + 1] = (a[i] >> 4) & 15;
+ }
+ /* each e[i] is between 0 and 15 */
+ /* e[63] is between 0 and 7 */
+
+ carry = 0;
+ for (i = 0;i < 63;++i) {
+ e[i] += carry;
+ carry = e[i] + 8;
+ carry >>= 4;
+ e[i] -= carry << 4;
+ }
+ e[63] += carry;
+ /* each e[i] is between -8 and 8 */
+
+ ge_p3_0(h);
+ for (i = 1;i < 64;i += 2) {
+ select(&t,i / 2,e[i]);
+ ge_madd(&r,h,&t); ge_p1p1_to_p3(h,&r);
+ }
+
+ ge_p3_dbl(&r,h); ge_p1p1_to_p2(&s,&r);
+ ge_p2_dbl(&r,&s); ge_p1p1_to_p2(&s,&r);
+ ge_p2_dbl(&r,&s); ge_p1p1_to_p2(&s,&r);
+ ge_p2_dbl(&r,&s); ge_p1p1_to_p3(h,&r);
+
+ for (i = 0;i < 64;i += 2) {
+ select(&t,i / 2,e[i]);
+ ge_madd(&r,h,&t); ge_p1p1_to_p3(h,&r);
+ }
+}
diff --git a/jni/ed25519/ge_sub.c b/jni/ed25519/ge_sub.c
new file mode 100644
index 00000000..69f3d540
--- /dev/null
+++ b/jni/ed25519/ge_sub.c
@@ -0,0 +1,11 @@
+#include "ge.h"
+
+/*
+r = p - q
+*/
+
+void ge_sub(ge_p1p1 *r,const ge_p3 *p,const ge_cached *q)
+{
+ fe t0;
+#include "ge_sub.h"
+}
diff --git a/jni/ed25519/ge_sub.h b/jni/ed25519/ge_sub.h
new file mode 100644
index 00000000..b4ef1f5d
--- /dev/null
+++ b/jni/ed25519/ge_sub.h
@@ -0,0 +1,97 @@
+
+/* qhasm: enter ge_sub */
+
+/* qhasm: fe X1 */
+
+/* qhasm: fe Y1 */
+
+/* qhasm: fe Z1 */
+
+/* qhasm: fe Z2 */
+
+/* qhasm: fe T1 */
+
+/* qhasm: fe ZZ */
+
+/* qhasm: fe YpX2 */
+
+/* qhasm: fe YmX2 */
+
+/* qhasm: fe T2d2 */
+
+/* qhasm: fe X3 */
+
+/* qhasm: fe Y3 */
+
+/* qhasm: fe Z3 */
+
+/* qhasm: fe T3 */
+
+/* qhasm: fe YpX1 */
+
+/* qhasm: fe YmX1 */
+
+/* qhasm: fe A */
+
+/* qhasm: fe B */
+
+/* qhasm: fe C */
+
+/* qhasm: fe D */
+
+/* qhasm: YpX1 = Y1+X1 */
+/* asm 1: fe_add(>YpX1=fe#1,<Y1=fe#12,<X1=fe#11); */
+/* asm 2: fe_add(>YpX1=r->X,<Y1=p->Y,<X1=p->X); */
+fe_add(r->X,p->Y,p->X);
+
+/* qhasm: YmX1 = Y1-X1 */
+/* asm 1: fe_sub(>YmX1=fe#2,<Y1=fe#12,<X1=fe#11); */
+/* asm 2: fe_sub(>YmX1=r->Y,<Y1=p->Y,<X1=p->X); */
+fe_sub(r->Y,p->Y,p->X);
+
+/* qhasm: A = YpX1*YmX2 */
+/* asm 1: fe_mul(>A=fe#3,<YpX1=fe#1,<YmX2=fe#16); */
+/* asm 2: fe_mul(>A=r->Z,<YpX1=r->X,<YmX2=q->YminusX); */
+fe_mul(r->Z,r->X,q->YminusX);
+
+/* qhasm: B = YmX1*YpX2 */
+/* asm 1: fe_mul(>B=fe#2,<YmX1=fe#2,<YpX2=fe#15); */
+/* asm 2: fe_mul(>B=r->Y,<YmX1=r->Y,<YpX2=q->YplusX); */
+fe_mul(r->Y,r->Y,q->YplusX);
+
+/* qhasm: C = T2d2*T1 */
+/* asm 1: fe_mul(>C=fe#4,<T2d2=fe#18,<T1=fe#14); */
+/* asm 2: fe_mul(>C=r->T,<T2d2=q->T2d,<T1=p->T); */
+fe_mul(r->T,q->T2d,p->T);
+
+/* qhasm: ZZ = Z1*Z2 */
+/* asm 1: fe_mul(>ZZ=fe#1,<Z1=fe#13,<Z2=fe#17); */
+/* asm 2: fe_mul(>ZZ=r->X,<Z1=p->Z,<Z2=q->Z); */
+fe_mul(r->X,p->Z,q->Z);
+
+/* qhasm: D = 2*ZZ */
+/* asm 1: fe_add(>D=fe#5,<ZZ=fe#1,<ZZ=fe#1); */
+/* asm 2: fe_add(>D=t0,<ZZ=r->X,<ZZ=r->X); */
+fe_add(t0,r->X,r->X);
+
+/* qhasm: X3 = A-B */
+/* asm 1: fe_sub(>X3=fe#1,<A=fe#3,<B=fe#2); */
+/* asm 2: fe_sub(>X3=r->X,<A=r->Z,<B=r->Y); */
+fe_sub(r->X,r->Z,r->Y);
+
+/* qhasm: Y3 = A+B */
+/* asm 1: fe_add(>Y3=fe#2,<A=fe#3,<B=fe#2); */
+/* asm 2: fe_add(>Y3=r->Y,<A=r->Z,<B=r->Y); */
+fe_add(r->Y,r->Z,r->Y);
+
+/* qhasm: Z3 = D-C */
+/* asm 1: fe_sub(>Z3=fe#3,<D=fe#5,<C=fe#4); */
+/* asm 2: fe_sub(>Z3=r->Z,<D=t0,<C=r->T); */
+fe_sub(r->Z,t0,r->T);
+
+/* qhasm: T3 = D+C */
+/* asm 1: fe_add(>T3=fe#4,<D=fe#5,<C=fe#4); */
+/* asm 2: fe_add(>T3=r->T,<D=t0,<C=r->T); */
+fe_add(r->T,t0,r->T);
+
+/* qhasm: return */
diff --git a/jni/ed25519/ge_tobytes.c b/jni/ed25519/ge_tobytes.c
new file mode 100644
index 00000000..31b3d33e
--- /dev/null
+++ b/jni/ed25519/ge_tobytes.c
@@ -0,0 +1,14 @@
+#include "ge.h"
+
+void ge_tobytes(unsigned char *s,const ge_p2 *h)
+{
+ fe recip;
+ fe x;
+ fe y;
+
+ fe_invert(recip,h->Z);
+ fe_mul(x,h->X,recip);
+ fe_mul(y,h->Y,recip);
+ fe_tobytes(s,y);
+ s[31] ^= fe_isnegative(x) << 7;
+}
diff --git a/jni/ed25519/main/main.c b/jni/ed25519/main/main.c
new file mode 100644
index 00000000..5fbe3995
--- /dev/null
+++ b/jni/ed25519/main/main.c
@@ -0,0 +1,106 @@
+#include <stdio.h>
+#include <string.h>
+#include "crypto_hash_sha512.h"
+#include "curve_sigs.h"
+
+#define MSG_LEN 200
+
+int main(int argc, char* argv[])
+{
+ unsigned char privkey[32];
+ unsigned char pubkey[32];
+ unsigned char signature[64];
+ unsigned char msg[MSG_LEN];
+ unsigned char random[64];
+
+ /* Initialize pubkey, privkey, msg */
+ memset(msg, 0, MSG_LEN);
+ memset(privkey, 0, 32);
+ memset(pubkey, 0, 32);
+ privkey[0] &= 248;
+ privkey[31] &= 63;
+ privkey[31] |= 64;
+
+ privkey[8] = 189; /* just so there's some bits set */
+
+
+ /* SHA512 test */
+ unsigned char sha512_input[112] = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu";
+ unsigned char sha512_correct_output[64] =
+{
+0x8E, 0x95, 0x9B, 0x75, 0xDA, 0xE3, 0x13, 0xDA,
+0x8C, 0xF4, 0xF7, 0x28, 0x14, 0xFC, 0x14, 0x3F,
+0x8F, 0x77, 0x79, 0xC6, 0xEB, 0x9F, 0x7F, 0xA1,
+0x72, 0x99, 0xAE, 0xAD, 0xB6, 0x88, 0x90, 0x18,
+0x50, 0x1D, 0x28, 0x9E, 0x49, 0x00, 0xF7, 0xE4,
+0x33, 0x1B, 0x99, 0xDE, 0xC4, 0xB5, 0x43, 0x3A,
+0xC7, 0xD3, 0x29, 0xEE, 0xB6, 0xDD, 0x26, 0x54,
+0x5E, 0x96, 0xE5, 0x5B, 0x87, 0x4B, 0xE9, 0x09
+};
+ unsigned char sha512_actual_output[64];
+
+ crypto_hash_sha512(sha512_actual_output, sha512_input, sizeof(sha512_input));
+ if (memcmp(sha512_actual_output, sha512_correct_output, 64) != 0)
+ printf("SHA512 bad #1\n");
+ else
+ printf("SHA512 good #1\n");
+
+ sha512_input[111] ^= 1;
+
+ crypto_hash_sha512(sha512_actual_output, sha512_input, sizeof(sha512_input));
+ if (memcmp(sha512_actual_output, sha512_correct_output, 64) != 0)
+ printf("SHA512 good #2\n");
+ else
+ printf("SHA512 bad #2\n");
+
+ /* Signature test */
+ curve25519_keygen(pubkey, privkey);
+
+ curve25519_sign(signature, privkey, msg, MSG_LEN, random);
+
+ if (curve25519_verify(signature, pubkey, msg, MSG_LEN) == 0)
+ printf("Signature good #1\n");
+ else
+ printf("Signature bad #1\n");
+
+ signature[0] ^= 1;
+
+ if (curve25519_verify(signature, pubkey, msg, MSG_LEN) == 0)
+ printf("Signature bad #2\n");
+ else
+ printf("Signature good #2\n");
+
+
+ printf("Random testing...\n");
+ for (int count = 0; count < 10000; count++) {
+ unsigned char b[64];
+ crypto_hash_sha512(b, privkey, 32);
+ memmove(privkey, b, 32);
+ crypto_hash_sha512(b, privkey, 32);
+ memmove(random, b, 64);
+
+ privkey[0] &= 248;
+ privkey[31] &= 63;
+ privkey[31] |= 64;
+
+ curve25519_keygen(pubkey, privkey);
+
+ curve25519_sign(signature, privkey, msg, MSG_LEN, random);
+
+ if (curve25519_verify(signature, pubkey, msg, MSG_LEN) != 0) {
+ printf("failure #1 %d\n", count);
+ return -1;
+ }
+
+ if (b[63] & 1)
+ signature[count % 64] ^= 1;
+ else
+ msg[count % MSG_LEN] ^= 1;
+ if (curve25519_verify(signature, pubkey, msg, MSG_LEN) == 0) {
+ printf("failure #2 %d\n", count);
+ return -1;
+ }
+ }
+ printf("OK\n");
+ return 1;
+}
diff --git a/jni/ed25519/nacl_includes/crypto_int32.h b/jni/ed25519/nacl_includes/crypto_int32.h
new file mode 100644
index 00000000..cae135e6
--- /dev/null
+++ b/jni/ed25519/nacl_includes/crypto_int32.h
@@ -0,0 +1,6 @@
+#ifndef crypto_int32_h
+#define crypto_int32_h
+
+typedef int crypto_int32;
+
+#endif
diff --git a/jni/ed25519/nacl_includes/crypto_int64.h b/jni/ed25519/nacl_includes/crypto_int64.h
new file mode 100644
index 00000000..fc92417b
--- /dev/null
+++ b/jni/ed25519/nacl_includes/crypto_int64.h
@@ -0,0 +1,6 @@
+#ifndef crypto_int64_h
+#define crypto_int64_h
+
+typedef long long crypto_int64;
+
+#endif
diff --git a/jni/ed25519/nacl_includes/crypto_sign.h b/jni/ed25519/nacl_includes/crypto_sign.h
new file mode 100644
index 00000000..8472603e
--- /dev/null
+++ b/jni/ed25519/nacl_includes/crypto_sign.h
@@ -0,0 +1,16 @@
+#ifndef crypto_sign_H
+#define crypto_sign_H
+
+#include "crypto_sign_edwards25519sha512batch.h"
+
+#define crypto_sign crypto_sign_edwards25519sha512batch
+#define crypto_sign_open crypto_sign_edwards25519sha512batch_open
+#define crypto_sign_keypair crypto_sign_edwards25519sha512batch_keypair
+#define crypto_sign_BYTES crypto_sign_edwards25519sha512batch_BYTES
+#define crypto_sign_PUBLICKEYBYTES crypto_sign_edwards25519sha512batch_PUBLICKEYBYTES
+#define crypto_sign_SECRETKEYBYTES crypto_sign_edwards25519sha512batch_SECRETKEYBYTES
+#define crypto_sign_PRIMITIVE "edwards25519sha512batch"
+#define crypto_sign_IMPLEMENTATION crypto_sign_edwards25519sha512batch_IMPLEMENTATION
+#define crypto_sign_VERSION crypto_sign_edwards25519sha512batch_VERSION
+
+#endif
diff --git a/jni/ed25519/nacl_includes/crypto_sign_edwards25519sha512batch.h b/jni/ed25519/nacl_includes/crypto_sign_edwards25519sha512batch.h
new file mode 100644
index 00000000..62fae611
--- /dev/null
+++ b/jni/ed25519/nacl_includes/crypto_sign_edwards25519sha512batch.h
@@ -0,0 +1,33 @@
+#ifndef crypto_sign_edwards25519sha512batch_H
+#define crypto_sign_edwards25519sha512batch_H
+
+#define crypto_sign_edwards25519sha512batch_ref10_SECRETKEYBYTES 64
+#define crypto_sign_edwards25519sha512batch_ref10_PUBLICKEYBYTES 32
+#define crypto_sign_edwards25519sha512batch_ref10_BYTES 64
+#ifdef __cplusplus
+#include <string>
+extern std::string crypto_sign_edwards25519sha512batch_ref10(const std::string &,const std::string &);
+extern std::string crypto_sign_edwards25519sha512batch_ref10_open(const std::string &,const std::string &);
+extern std::string crypto_sign_edwards25519sha512batch_ref10_keypair(std::string *);
+extern "C" {
+#endif
+extern int crypto_sign_edwards25519sha512batch_ref10(unsigned char *,unsigned long long *,const unsigned char *,unsigned long long,const unsigned char *);
+extern int crypto_sign_edwards25519sha512batch_ref10_open(unsigned char *,unsigned long long *,const unsigned char *,unsigned long long,const unsigned char *);
+extern int crypto_sign_edwards25519sha512batch_ref10_keypair(unsigned char *,unsigned char *);
+#ifdef __cplusplus
+}
+#endif
+
+#define crypto_sign_edwards25519sha512batch crypto_sign_edwards25519sha512batch_ref10
+#define crypto_sign_edwards25519sha512batch_open crypto_sign_edwards25519sha512batch_ref10_open
+#define crypto_sign_edwards25519sha512batch_keypair crypto_sign_edwards25519sha512batch_ref10_keypair
+#define crypto_sign_edwards25519sha512batch_BYTES crypto_sign_edwards25519sha512batch_ref10_BYTES
+#define crypto_sign_edwards25519sha512batch_PUBLICKEYBYTES crypto_sign_edwards25519sha512batch_ref10_PUBLICKEYBYTES
+#define crypto_sign_edwards25519sha512batch_SECRETKEYBYTES crypto_sign_edwards25519sha512batch_ref10_SECRETKEYBYTES
+#define crypto_sign_edwards25519sha512batch_IMPLEMENTATION "crypto_sign/edwards25519sha512batch/ref10"
+#ifndef crypto_sign_edwards25519sha512batch_ref10_VERSION
+#define crypto_sign_edwards25519sha512batch_ref10_VERSION "-"
+#endif
+#define crypto_sign_edwards25519sha512batch_VERSION crypto_sign_edwards25519sha512batch_ref10_VERSION
+
+#endif
diff --git a/jni/ed25519/nacl_includes/crypto_uint32.h b/jni/ed25519/nacl_includes/crypto_uint32.h
new file mode 100644
index 00000000..21020d7b
--- /dev/null
+++ b/jni/ed25519/nacl_includes/crypto_uint32.h
@@ -0,0 +1,6 @@
+#ifndef crypto_uint32_h
+#define crypto_uint32_h
+
+typedef unsigned int crypto_uint32;
+
+#endif
diff --git a/jni/ed25519/nacl_includes/crypto_uint64.h b/jni/ed25519/nacl_includes/crypto_uint64.h
new file mode 100644
index 00000000..5aa00703
--- /dev/null
+++ b/jni/ed25519/nacl_includes/crypto_uint64.h
@@ -0,0 +1,6 @@
+#ifndef crypto_uint64_h
+#define crypto_uint64_h
+
+typedef unsigned long long crypto_uint64;
+
+#endif
diff --git a/jni/ed25519/nacl_includes/crypto_verify_32.h b/jni/ed25519/nacl_includes/crypto_verify_32.h
new file mode 100644
index 00000000..978d8452
--- /dev/null
+++ b/jni/ed25519/nacl_includes/crypto_verify_32.h
@@ -0,0 +1,22 @@
+#ifndef crypto_verify_32_H
+#define crypto_verify_32_H
+
+#define crypto_verify_32_ref_BYTES 32
+#ifdef __cplusplus
+#include <string>
+extern "C" {
+#endif
+extern int crypto_verify_32_ref(const unsigned char *,const unsigned char *);
+#ifdef __cplusplus
+}
+#endif
+
+#define crypto_verify_32 crypto_verify_32_ref
+#define crypto_verify_32_BYTES crypto_verify_32_ref_BYTES
+#define crypto_verify_32_IMPLEMENTATION "crypto_verify/32/ref"
+#ifndef crypto_verify_32_ref_VERSION
+#define crypto_verify_32_ref_VERSION "-"
+#endif
+#define crypto_verify_32_VERSION crypto_verify_32_ref_VERSION
+
+#endif
diff --git a/jni/ed25519/nacl_sha512/blocks.c b/jni/ed25519/nacl_sha512/blocks.c
new file mode 100644
index 00000000..1c5f23d5
--- /dev/null
+++ b/jni/ed25519/nacl_sha512/blocks.c
@@ -0,0 +1,238 @@
+#include <stdint.h>
+typedef uint64_t uint64;
+
+static uint64 load_bigendian(const unsigned char *x)
+{
+ return
+ (uint64) (x[7]) \
+ | (((uint64) (x[6])) << 8) \
+ | (((uint64) (x[5])) << 16) \
+ | (((uint64) (x[4])) << 24) \
+ | (((uint64) (x[3])) << 32) \
+ | (((uint64) (x[2])) << 40) \
+ | (((uint64) (x[1])) << 48) \
+ | (((uint64) (x[0])) << 56)
+ ;
+}
+
+static void store_bigendian(unsigned char *x,uint64 u)
+{
+ x[7] = u; u >>= 8;
+ x[6] = u; u >>= 8;
+ x[5] = u; u >>= 8;
+ x[4] = u; u >>= 8;
+ x[3] = u; u >>= 8;
+ x[2] = u; u >>= 8;
+ x[1] = u; u >>= 8;
+ x[0] = u;
+}
+
+#define SHR(x,c) ((x) >> (c))
+#define ROTR(x,c) (((x) >> (c)) | ((x) << (64 - (c))))
+
+#define Ch(x,y,z) ((x & y) ^ (~x & z))
+#define Maj(x,y,z) ((x & y) ^ (x & z) ^ (y & z))
+#define Sigma0(x) (ROTR(x,28) ^ ROTR(x,34) ^ ROTR(x,39))
+#define Sigma1(x) (ROTR(x,14) ^ ROTR(x,18) ^ ROTR(x,41))
+#define sigma0(x) (ROTR(x, 1) ^ ROTR(x, 8) ^ SHR(x,7))
+#define sigma1(x) (ROTR(x,19) ^ ROTR(x,61) ^ SHR(x,6))
+
+#define M(w0,w14,w9,w1) w0 = sigma1(w14) + w9 + sigma0(w1) + w0;
+
+#define EXPAND \
+ M(w0 ,w14,w9 ,w1 ) \
+ M(w1 ,w15,w10,w2 ) \
+ M(w2 ,w0 ,w11,w3 ) \
+ M(w3 ,w1 ,w12,w4 ) \
+ M(w4 ,w2 ,w13,w5 ) \
+ M(w5 ,w3 ,w14,w6 ) \
+ M(w6 ,w4 ,w15,w7 ) \
+ M(w7 ,w5 ,w0 ,w8 ) \
+ M(w8 ,w6 ,w1 ,w9 ) \
+ M(w9 ,w7 ,w2 ,w10) \
+ M(w10,w8 ,w3 ,w11) \
+ M(w11,w9 ,w4 ,w12) \
+ M(w12,w10,w5 ,w13) \
+ M(w13,w11,w6 ,w14) \
+ M(w14,w12,w7 ,w15) \
+ M(w15,w13,w8 ,w0 )
+
+#define F(w,k) \
+ T1 = h + Sigma1(e) + Ch(e,f,g) + k + w; \
+ T2 = Sigma0(a) + Maj(a,b,c); \
+ h = g; \
+ g = f; \
+ f = e; \
+ e = d + T1; \
+ d = c; \
+ c = b; \
+ b = a; \
+ a = T1 + T2;
+
+int crypto_hashblocks_sha512(unsigned char *statebytes,const unsigned char *in,unsigned long long inlen)
+{
+ uint64 state[8];
+ uint64 a;
+ uint64 b;
+ uint64 c;
+ uint64 d;
+ uint64 e;
+ uint64 f;
+ uint64 g;
+ uint64 h;
+ uint64 T1;
+ uint64 T2;
+
+ a = load_bigendian(statebytes + 0); state[0] = a;
+ b = load_bigendian(statebytes + 8); state[1] = b;
+ c = load_bigendian(statebytes + 16); state[2] = c;
+ d = load_bigendian(statebytes + 24); state[3] = d;
+ e = load_bigendian(statebytes + 32); state[4] = e;
+ f = load_bigendian(statebytes + 40); state[5] = f;
+ g = load_bigendian(statebytes + 48); state[6] = g;
+ h = load_bigendian(statebytes + 56); state[7] = h;
+
+ while (inlen >= 128) {
+ uint64 w0 = load_bigendian(in + 0);
+ uint64 w1 = load_bigendian(in + 8);
+ uint64 w2 = load_bigendian(in + 16);
+ uint64 w3 = load_bigendian(in + 24);
+ uint64 w4 = load_bigendian(in + 32);
+ uint64 w5 = load_bigendian(in + 40);
+ uint64 w6 = load_bigendian(in + 48);
+ uint64 w7 = load_bigendian(in + 56);
+ uint64 w8 = load_bigendian(in + 64);
+ uint64 w9 = load_bigendian(in + 72);
+ uint64 w10 = load_bigendian(in + 80);
+ uint64 w11 = load_bigendian(in + 88);
+ uint64 w12 = load_bigendian(in + 96);
+ uint64 w13 = load_bigendian(in + 104);
+ uint64 w14 = load_bigendian(in + 112);
+ uint64 w15 = load_bigendian(in + 120);
+
+ F(w0 ,0x428a2f98d728ae22ULL)
+ F(w1 ,0x7137449123ef65cdULL)
+ F(w2 ,0xb5c0fbcfec4d3b2fULL)
+ F(w3 ,0xe9b5dba58189dbbcULL)
+ F(w4 ,0x3956c25bf348b538ULL)
+ F(w5 ,0x59f111f1b605d019ULL)
+ F(w6 ,0x923f82a4af194f9bULL)
+ F(w7 ,0xab1c5ed5da6d8118ULL)
+ F(w8 ,0xd807aa98a3030242ULL)
+ F(w9 ,0x12835b0145706fbeULL)
+ F(w10,0x243185be4ee4b28cULL)
+ F(w11,0x550c7dc3d5ffb4e2ULL)
+ F(w12,0x72be5d74f27b896fULL)
+ F(w13,0x80deb1fe3b1696b1ULL)
+ F(w14,0x9bdc06a725c71235ULL)
+ F(w15,0xc19bf174cf692694ULL)
+
+ EXPAND
+
+ F(w0 ,0xe49b69c19ef14ad2ULL)
+ F(w1 ,0xefbe4786384f25e3ULL)
+ F(w2 ,0x0fc19dc68b8cd5b5ULL)
+ F(w3 ,0x240ca1cc77ac9c65ULL)
+ F(w4 ,0x2de92c6f592b0275ULL)
+ F(w5 ,0x4a7484aa6ea6e483ULL)
+ F(w6 ,0x5cb0a9dcbd41fbd4ULL)
+ F(w7 ,0x76f988da831153b5ULL)
+ F(w8 ,0x983e5152ee66dfabULL)
+ F(w9 ,0xa831c66d2db43210ULL)
+ F(w10,0xb00327c898fb213fULL)
+ F(w11,0xbf597fc7beef0ee4ULL)
+ F(w12,0xc6e00bf33da88fc2ULL)
+ F(w13,0xd5a79147930aa725ULL)
+ F(w14,0x06ca6351e003826fULL)
+ F(w15,0x142929670a0e6e70ULL)
+
+ EXPAND
+
+ F(w0 ,0x27b70a8546d22ffcULL)
+ F(w1 ,0x2e1b21385c26c926ULL)
+ F(w2 ,0x4d2c6dfc5ac42aedULL)
+ F(w3 ,0x53380d139d95b3dfULL)
+ F(w4 ,0x650a73548baf63deULL)
+ F(w5 ,0x766a0abb3c77b2a8ULL)
+ F(w6 ,0x81c2c92e47edaee6ULL)
+ F(w7 ,0x92722c851482353bULL)
+ F(w8 ,0xa2bfe8a14cf10364ULL)
+ F(w9 ,0xa81a664bbc423001ULL)
+ F(w10,0xc24b8b70d0f89791ULL)
+ F(w11,0xc76c51a30654be30ULL)
+ F(w12,0xd192e819d6ef5218ULL)
+ F(w13,0xd69906245565a910ULL)
+ F(w14,0xf40e35855771202aULL)
+ F(w15,0x106aa07032bbd1b8ULL)
+
+ EXPAND
+
+ F(w0 ,0x19a4c116b8d2d0c8ULL)
+ F(w1 ,0x1e376c085141ab53ULL)
+ F(w2 ,0x2748774cdf8eeb99ULL)
+ F(w3 ,0x34b0bcb5e19b48a8ULL)
+ F(w4 ,0x391c0cb3c5c95a63ULL)
+ F(w5 ,0x4ed8aa4ae3418acbULL)
+ F(w6 ,0x5b9cca4f7763e373ULL)
+ F(w7 ,0x682e6ff3d6b2b8a3ULL)
+ F(w8 ,0x748f82ee5defb2fcULL)
+ F(w9 ,0x78a5636f43172f60ULL)
+ F(w10,0x84c87814a1f0ab72ULL)
+ F(w11,0x8cc702081a6439ecULL)
+ F(w12,0x90befffa23631e28ULL)
+ F(w13,0xa4506cebde82bde9ULL)
+ F(w14,0xbef9a3f7b2c67915ULL)
+ F(w15,0xc67178f2e372532bULL)
+
+ EXPAND
+
+ F(w0 ,0xca273eceea26619cULL)
+ F(w1 ,0xd186b8c721c0c207ULL)
+ F(w2 ,0xeada7dd6cde0eb1eULL)
+ F(w3 ,0xf57d4f7fee6ed178ULL)
+ F(w4 ,0x06f067aa72176fbaULL)
+ F(w5 ,0x0a637dc5a2c898a6ULL)
+ F(w6 ,0x113f9804bef90daeULL)
+ F(w7 ,0x1b710b35131c471bULL)
+ F(w8 ,0x28db77f523047d84ULL)
+ F(w9 ,0x32caab7b40c72493ULL)
+ F(w10,0x3c9ebe0a15c9bebcULL)
+ F(w11,0x431d67c49c100d4cULL)
+ F(w12,0x4cc5d4becb3e42b6ULL)
+ F(w13,0x597f299cfc657e2aULL)
+ F(w14,0x5fcb6fab3ad6faecULL)
+ F(w15,0x6c44198c4a475817ULL)
+
+ a += state[0];
+ b += state[1];
+ c += state[2];
+ d += state[3];
+ e += state[4];
+ f += state[5];
+ g += state[6];
+ h += state[7];
+
+ state[0] = a;
+ state[1] = b;
+ state[2] = c;
+ state[3] = d;
+ state[4] = e;
+ state[5] = f;
+ state[6] = g;
+ state[7] = h;
+
+ in += 128;
+ inlen -= 128;
+ }
+
+ store_bigendian(statebytes + 0,state[0]);
+ store_bigendian(statebytes + 8,state[1]);
+ store_bigendian(statebytes + 16,state[2]);
+ store_bigendian(statebytes + 24,state[3]);
+ store_bigendian(statebytes + 32,state[4]);
+ store_bigendian(statebytes + 40,state[5]);
+ store_bigendian(statebytes + 48,state[6]);
+ store_bigendian(statebytes + 56,state[7]);
+
+ return 0;
+}
diff --git a/jni/ed25519/nacl_sha512/hash.c b/jni/ed25519/nacl_sha512/hash.c
new file mode 100644
index 00000000..8934cc18
--- /dev/null
+++ b/jni/ed25519/nacl_sha512/hash.c
@@ -0,0 +1,71 @@
+/*
+20080913
+D. J. Bernstein
+Public domain.
+*/
+
+#include <stdint.h>
+typedef uint64_t uint64;
+
+extern int crypto_hashblocks_sha512(unsigned char *statebytes,const unsigned char *in,unsigned long long inlen);
+
+#define blocks crypto_hashblocks_sha512
+
+static const unsigned char iv[64] = {
+ 0x6a,0x09,0xe6,0x67,0xf3,0xbc,0xc9,0x08,
+ 0xbb,0x67,0xae,0x85,0x84,0xca,0xa7,0x3b,
+ 0x3c,0x6e,0xf3,0x72,0xfe,0x94,0xf8,0x2b,
+ 0xa5,0x4f,0xf5,0x3a,0x5f,0x1d,0x36,0xf1,
+ 0x51,0x0e,0x52,0x7f,0xad,0xe6,0x82,0xd1,
+ 0x9b,0x05,0x68,0x8c,0x2b,0x3e,0x6c,0x1f,
+ 0x1f,0x83,0xd9,0xab,0xfb,0x41,0xbd,0x6b,
+ 0x5b,0xe0,0xcd,0x19,0x13,0x7e,0x21,0x79
+} ;
+
+int crypto_hash_sha512(unsigned char *out,const unsigned char *in,unsigned long long inlen)
+{
+ unsigned char h[64];
+ unsigned char padded[256];
+ int i;
+ unsigned long long bytes = inlen;
+
+ for (i = 0;i < 64;++i) h[i] = iv[i];
+
+ blocks(h,in,inlen);
+ in += inlen;
+ inlen &= 127;
+ in -= inlen;
+
+ for (i = 0;i < inlen;++i) padded[i] = in[i];
+ padded[inlen] = 0x80;
+
+ if (inlen < 112) {
+ for (i = inlen + 1;i < 119;++i) padded[i] = 0;
+ padded[119] = bytes >> 61;
+ padded[120] = bytes >> 53;
+ padded[121] = bytes >> 45;
+ padded[122] = bytes >> 37;
+ padded[123] = bytes >> 29;
+ padded[124] = bytes >> 21;
+ padded[125] = bytes >> 13;
+ padded[126] = bytes >> 5;
+ padded[127] = bytes << 3;
+ blocks(h,padded,128);
+ } else {
+ for (i = inlen + 1;i < 247;++i) padded[i] = 0;
+ padded[247] = bytes >> 61;
+ padded[248] = bytes >> 53;
+ padded[249] = bytes >> 45;
+ padded[250] = bytes >> 37;
+ padded[251] = bytes >> 29;
+ padded[252] = bytes >> 21;
+ padded[253] = bytes >> 13;
+ padded[254] = bytes >> 5;
+ padded[255] = bytes << 3;
+ blocks(h,padded,256);
+ }
+
+ for (i = 0;i < 64;++i) out[i] = h[i];
+
+ return 0;
+}
diff --git a/jni/ed25519/open.c b/jni/ed25519/open.c
new file mode 100644
index 00000000..1ec4cd2b
--- /dev/null
+++ b/jni/ed25519/open.c
@@ -0,0 +1,48 @@
+#include <string.h>
+#include "crypto_sign.h"
+#include "crypto_hash_sha512.h"
+#include "crypto_verify_32.h"
+#include "ge.h"
+#include "sc.h"
+
+int crypto_sign_open(
+ unsigned char *m,unsigned long long *mlen,
+ const unsigned char *sm,unsigned long long smlen,
+ const unsigned char *pk
+)
+{
+ unsigned char pkcopy[32];
+ unsigned char rcopy[32];
+ unsigned char scopy[32];
+ unsigned char h[64];
+ unsigned char rcheck[32];
+ ge_p3 A;
+ ge_p2 R;
+
+ if (smlen < 64) goto badsig;
+ if (sm[63] & 224) goto badsig;
+ if (ge_frombytes_negate_vartime(&A,pk) != 0) goto badsig;
+
+ memmove(pkcopy,pk,32);
+ memmove(rcopy,sm,32);
+ memmove(scopy,sm + 32,32);
+
+ memmove(m,sm,smlen);
+ memmove(m + 32,pkcopy,32);
+ crypto_hash_sha512(h,m,smlen);
+ sc_reduce(h);
+
+ ge_double_scalarmult_vartime(&R,h,&A,scopy);
+ ge_tobytes(rcheck,&R);
+ if (crypto_verify_32(rcheck,rcopy) == 0) {
+ memmove(m,m + 64,smlen - 64);
+ memset(m + smlen - 64,0,64);
+ *mlen = smlen - 64;
+ return 0;
+ }
+
+badsig:
+ *mlen = -1;
+ memset(m,0,smlen);
+ return -1;
+}
diff --git a/jni/ed25519/pow22523.h b/jni/ed25519/pow22523.h
new file mode 100644
index 00000000..60ffe0d3
--- /dev/null
+++ b/jni/ed25519/pow22523.h
@@ -0,0 +1,160 @@
+
+/* qhasm: fe z1 */
+
+/* qhasm: fe z2 */
+
+/* qhasm: fe z8 */
+
+/* qhasm: fe z9 */
+
+/* qhasm: fe z11 */
+
+/* qhasm: fe z22 */
+
+/* qhasm: fe z_5_0 */
+
+/* qhasm: fe z_10_5 */
+
+/* qhasm: fe z_10_0 */
+
+/* qhasm: fe z_20_10 */
+
+/* qhasm: fe z_20_0 */
+
+/* qhasm: fe z_40_20 */
+
+/* qhasm: fe z_40_0 */
+
+/* qhasm: fe z_50_10 */
+
+/* qhasm: fe z_50_0 */
+
+/* qhasm: fe z_100_50 */
+
+/* qhasm: fe z_100_0 */
+
+/* qhasm: fe z_200_100 */
+
+/* qhasm: fe z_200_0 */
+
+/* qhasm: fe z_250_50 */
+
+/* qhasm: fe z_250_0 */
+
+/* qhasm: fe z_252_2 */
+
+/* qhasm: fe z_252_3 */
+
+/* qhasm: enter pow22523 */
+
+/* qhasm: z2 = z1^2^1 */
+/* asm 1: fe_sq(>z2=fe#1,<z1=fe#11); for (i = 1;i < 1;++i) fe_sq(>z2=fe#1,>z2=fe#1); */
+/* asm 2: fe_sq(>z2=t0,<z1=z); for (i = 1;i < 1;++i) fe_sq(>z2=t0,>z2=t0); */
+fe_sq(t0,z); for (i = 1;i < 1;++i) fe_sq(t0,t0);
+
+/* qhasm: z8 = z2^2^2 */
+/* asm 1: fe_sq(>z8=fe#2,<z2=fe#1); for (i = 1;i < 2;++i) fe_sq(>z8=fe#2,>z8=fe#2); */
+/* asm 2: fe_sq(>z8=t1,<z2=t0); for (i = 1;i < 2;++i) fe_sq(>z8=t1,>z8=t1); */
+fe_sq(t1,t0); for (i = 1;i < 2;++i) fe_sq(t1,t1);
+
+/* qhasm: z9 = z1*z8 */
+/* asm 1: fe_mul(>z9=fe#2,<z1=fe#11,<z8=fe#2); */
+/* asm 2: fe_mul(>z9=t1,<z1=z,<z8=t1); */
+fe_mul(t1,z,t1);
+
+/* qhasm: z11 = z2*z9 */
+/* asm 1: fe_mul(>z11=fe#1,<z2=fe#1,<z9=fe#2); */
+/* asm 2: fe_mul(>z11=t0,<z2=t0,<z9=t1); */
+fe_mul(t0,t0,t1);
+
+/* qhasm: z22 = z11^2^1 */
+/* asm 1: fe_sq(>z22=fe#1,<z11=fe#1); for (i = 1;i < 1;++i) fe_sq(>z22=fe#1,>z22=fe#1); */
+/* asm 2: fe_sq(>z22=t0,<z11=t0); for (i = 1;i < 1;++i) fe_sq(>z22=t0,>z22=t0); */
+fe_sq(t0,t0); for (i = 1;i < 1;++i) fe_sq(t0,t0);
+
+/* qhasm: z_5_0 = z9*z22 */
+/* asm 1: fe_mul(>z_5_0=fe#1,<z9=fe#2,<z22=fe#1); */
+/* asm 2: fe_mul(>z_5_0=t0,<z9=t1,<z22=t0); */
+fe_mul(t0,t1,t0);
+
+/* qhasm: z_10_5 = z_5_0^2^5 */
+/* asm 1: fe_sq(>z_10_5=fe#2,<z_5_0=fe#1); for (i = 1;i < 5;++i) fe_sq(>z_10_5=fe#2,>z_10_5=fe#2); */
+/* asm 2: fe_sq(>z_10_5=t1,<z_5_0=t0); for (i = 1;i < 5;++i) fe_sq(>z_10_5=t1,>z_10_5=t1); */
+fe_sq(t1,t0); for (i = 1;i < 5;++i) fe_sq(t1,t1);
+
+/* qhasm: z_10_0 = z_10_5*z_5_0 */
+/* asm 1: fe_mul(>z_10_0=fe#1,<z_10_5=fe#2,<z_5_0=fe#1); */
+/* asm 2: fe_mul(>z_10_0=t0,<z_10_5=t1,<z_5_0=t0); */
+fe_mul(t0,t1,t0);
+
+/* qhasm: z_20_10 = z_10_0^2^10 */
+/* asm 1: fe_sq(>z_20_10=fe#2,<z_10_0=fe#1); for (i = 1;i < 10;++i) fe_sq(>z_20_10=fe#2,>z_20_10=fe#2); */
+/* asm 2: fe_sq(>z_20_10=t1,<z_10_0=t0); for (i = 1;i < 10;++i) fe_sq(>z_20_10=t1,>z_20_10=t1); */
+fe_sq(t1,t0); for (i = 1;i < 10;++i) fe_sq(t1,t1);
+
+/* qhasm: z_20_0 = z_20_10*z_10_0 */
+/* asm 1: fe_mul(>z_20_0=fe#2,<z_20_10=fe#2,<z_10_0=fe#1); */
+/* asm 2: fe_mul(>z_20_0=t1,<z_20_10=t1,<z_10_0=t0); */
+fe_mul(t1,t1,t0);
+
+/* qhasm: z_40_20 = z_20_0^2^20 */
+/* asm 1: fe_sq(>z_40_20=fe#3,<z_20_0=fe#2); for (i = 1;i < 20;++i) fe_sq(>z_40_20=fe#3,>z_40_20=fe#3); */
+/* asm 2: fe_sq(>z_40_20=t2,<z_20_0=t1); for (i = 1;i < 20;++i) fe_sq(>z_40_20=t2,>z_40_20=t2); */
+fe_sq(t2,t1); for (i = 1;i < 20;++i) fe_sq(t2,t2);
+
+/* qhasm: z_40_0 = z_40_20*z_20_0 */
+/* asm 1: fe_mul(>z_40_0=fe#2,<z_40_20=fe#3,<z_20_0=fe#2); */
+/* asm 2: fe_mul(>z_40_0=t1,<z_40_20=t2,<z_20_0=t1); */
+fe_mul(t1,t2,t1);
+
+/* qhasm: z_50_10 = z_40_0^2^10 */
+/* asm 1: fe_sq(>z_50_10=fe#2,<z_40_0=fe#2); for (i = 1;i < 10;++i) fe_sq(>z_50_10=fe#2,>z_50_10=fe#2); */
+/* asm 2: fe_sq(>z_50_10=t1,<z_40_0=t1); for (i = 1;i < 10;++i) fe_sq(>z_50_10=t1,>z_50_10=t1); */
+fe_sq(t1,t1); for (i = 1;i < 10;++i) fe_sq(t1,t1);
+
+/* qhasm: z_50_0 = z_50_10*z_10_0 */
+/* asm 1: fe_mul(>z_50_0=fe#1,<z_50_10=fe#2,<z_10_0=fe#1); */
+/* asm 2: fe_mul(>z_50_0=t0,<z_50_10=t1,<z_10_0=t0); */
+fe_mul(t0,t1,t0);
+
+/* qhasm: z_100_50 = z_50_0^2^50 */
+/* asm 1: fe_sq(>z_100_50=fe#2,<z_50_0=fe#1); for (i = 1;i < 50;++i) fe_sq(>z_100_50=fe#2,>z_100_50=fe#2); */
+/* asm 2: fe_sq(>z_100_50=t1,<z_50_0=t0); for (i = 1;i < 50;++i) fe_sq(>z_100_50=t1,>z_100_50=t1); */
+fe_sq(t1,t0); for (i = 1;i < 50;++i) fe_sq(t1,t1);
+
+/* qhasm: z_100_0 = z_100_50*z_50_0 */
+/* asm 1: fe_mul(>z_100_0=fe#2,<z_100_50=fe#2,<z_50_0=fe#1); */
+/* asm 2: fe_mul(>z_100_0=t1,<z_100_50=t1,<z_50_0=t0); */
+fe_mul(t1,t1,t0);
+
+/* qhasm: z_200_100 = z_100_0^2^100 */
+/* asm 1: fe_sq(>z_200_100=fe#3,<z_100_0=fe#2); for (i = 1;i < 100;++i) fe_sq(>z_200_100=fe#3,>z_200_100=fe#3); */
+/* asm 2: fe_sq(>z_200_100=t2,<z_100_0=t1); for (i = 1;i < 100;++i) fe_sq(>z_200_100=t2,>z_200_100=t2); */
+fe_sq(t2,t1); for (i = 1;i < 100;++i) fe_sq(t2,t2);
+
+/* qhasm: z_200_0 = z_200_100*z_100_0 */
+/* asm 1: fe_mul(>z_200_0=fe#2,<z_200_100=fe#3,<z_100_0=fe#2); */
+/* asm 2: fe_mul(>z_200_0=t1,<z_200_100=t2,<z_100_0=t1); */
+fe_mul(t1,t2,t1);
+
+/* qhasm: z_250_50 = z_200_0^2^50 */
+/* asm 1: fe_sq(>z_250_50=fe#2,<z_200_0=fe#2); for (i = 1;i < 50;++i) fe_sq(>z_250_50=fe#2,>z_250_50=fe#2); */
+/* asm 2: fe_sq(>z_250_50=t1,<z_200_0=t1); for (i = 1;i < 50;++i) fe_sq(>z_250_50=t1,>z_250_50=t1); */
+fe_sq(t1,t1); for (i = 1;i < 50;++i) fe_sq(t1,t1);
+
+/* qhasm: z_250_0 = z_250_50*z_50_0 */
+/* asm 1: fe_mul(>z_250_0=fe#1,<z_250_50=fe#2,<z_50_0=fe#1); */
+/* asm 2: fe_mul(>z_250_0=t0,<z_250_50=t1,<z_50_0=t0); */
+fe_mul(t0,t1,t0);
+
+/* qhasm: z_252_2 = z_250_0^2^2 */
+/* asm 1: fe_sq(>z_252_2=fe#1,<z_250_0=fe#1); for (i = 1;i < 2;++i) fe_sq(>z_252_2=fe#1,>z_252_2=fe#1); */
+/* asm 2: fe_sq(>z_252_2=t0,<z_250_0=t0); for (i = 1;i < 2;++i) fe_sq(>z_252_2=t0,>z_252_2=t0); */
+fe_sq(t0,t0); for (i = 1;i < 2;++i) fe_sq(t0,t0);
+
+/* qhasm: z_252_3 = z_252_2*z1 */
+/* asm 1: fe_mul(>z_252_3=fe#12,<z_252_2=fe#1,<z1=fe#11); */
+/* asm 2: fe_mul(>z_252_3=out,<z_252_2=t0,<z1=z); */
+fe_mul(out,t0,z);
+
+/* qhasm: return */
diff --git a/jni/ed25519/pow225521.h b/jni/ed25519/pow225521.h
new file mode 100644
index 00000000..109df779
--- /dev/null
+++ b/jni/ed25519/pow225521.h
@@ -0,0 +1,160 @@
+
+/* qhasm: fe z1 */
+
+/* qhasm: fe z2 */
+
+/* qhasm: fe z8 */
+
+/* qhasm: fe z9 */
+
+/* qhasm: fe z11 */
+
+/* qhasm: fe z22 */
+
+/* qhasm: fe z_5_0 */
+
+/* qhasm: fe z_10_5 */
+
+/* qhasm: fe z_10_0 */
+
+/* qhasm: fe z_20_10 */
+
+/* qhasm: fe z_20_0 */
+
+/* qhasm: fe z_40_20 */
+
+/* qhasm: fe z_40_0 */
+
+/* qhasm: fe z_50_10 */
+
+/* qhasm: fe z_50_0 */
+
+/* qhasm: fe z_100_50 */
+
+/* qhasm: fe z_100_0 */
+
+/* qhasm: fe z_200_100 */
+
+/* qhasm: fe z_200_0 */
+
+/* qhasm: fe z_250_50 */
+
+/* qhasm: fe z_250_0 */
+
+/* qhasm: fe z_255_5 */
+
+/* qhasm: fe z_255_21 */
+
+/* qhasm: enter pow225521 */
+
+/* qhasm: z2 = z1^2^1 */
+/* asm 1: fe_sq(>z2=fe#1,<z1=fe#11); for (i = 1;i < 1;++i) fe_sq(>z2=fe#1,>z2=fe#1); */
+/* asm 2: fe_sq(>z2=t0,<z1=z); for (i = 1;i < 1;++i) fe_sq(>z2=t0,>z2=t0); */
+fe_sq(t0,z); for (i = 1;i < 1;++i) fe_sq(t0,t0);
+
+/* qhasm: z8 = z2^2^2 */
+/* asm 1: fe_sq(>z8=fe#2,<z2=fe#1); for (i = 1;i < 2;++i) fe_sq(>z8=fe#2,>z8=fe#2); */
+/* asm 2: fe_sq(>z8=t1,<z2=t0); for (i = 1;i < 2;++i) fe_sq(>z8=t1,>z8=t1); */
+fe_sq(t1,t0); for (i = 1;i < 2;++i) fe_sq(t1,t1);
+
+/* qhasm: z9 = z1*z8 */
+/* asm 1: fe_mul(>z9=fe#2,<z1=fe#11,<z8=fe#2); */
+/* asm 2: fe_mul(>z9=t1,<z1=z,<z8=t1); */
+fe_mul(t1,z,t1);
+
+/* qhasm: z11 = z2*z9 */
+/* asm 1: fe_mul(>z11=fe#1,<z2=fe#1,<z9=fe#2); */
+/* asm 2: fe_mul(>z11=t0,<z2=t0,<z9=t1); */
+fe_mul(t0,t0,t1);
+
+/* qhasm: z22 = z11^2^1 */
+/* asm 1: fe_sq(>z22=fe#3,<z11=fe#1); for (i = 1;i < 1;++i) fe_sq(>z22=fe#3,>z22=fe#3); */
+/* asm 2: fe_sq(>z22=t2,<z11=t0); for (i = 1;i < 1;++i) fe_sq(>z22=t2,>z22=t2); */
+fe_sq(t2,t0); for (i = 1;i < 1;++i) fe_sq(t2,t2);
+
+/* qhasm: z_5_0 = z9*z22 */
+/* asm 1: fe_mul(>z_5_0=fe#2,<z9=fe#2,<z22=fe#3); */
+/* asm 2: fe_mul(>z_5_0=t1,<z9=t1,<z22=t2); */
+fe_mul(t1,t1,t2);
+
+/* qhasm: z_10_5 = z_5_0^2^5 */
+/* asm 1: fe_sq(>z_10_5=fe#3,<z_5_0=fe#2); for (i = 1;i < 5;++i) fe_sq(>z_10_5=fe#3,>z_10_5=fe#3); */
+/* asm 2: fe_sq(>z_10_5=t2,<z_5_0=t1); for (i = 1;i < 5;++i) fe_sq(>z_10_5=t2,>z_10_5=t2); */
+fe_sq(t2,t1); for (i = 1;i < 5;++i) fe_sq(t2,t2);
+
+/* qhasm: z_10_0 = z_10_5*z_5_0 */
+/* asm 1: fe_mul(>z_10_0=fe#2,<z_10_5=fe#3,<z_5_0=fe#2); */
+/* asm 2: fe_mul(>z_10_0=t1,<z_10_5=t2,<z_5_0=t1); */
+fe_mul(t1,t2,t1);
+
+/* qhasm: z_20_10 = z_10_0^2^10 */
+/* asm 1: fe_sq(>z_20_10=fe#3,<z_10_0=fe#2); for (i = 1;i < 10;++i) fe_sq(>z_20_10=fe#3,>z_20_10=fe#3); */
+/* asm 2: fe_sq(>z_20_10=t2,<z_10_0=t1); for (i = 1;i < 10;++i) fe_sq(>z_20_10=t2,>z_20_10=t2); */
+fe_sq(t2,t1); for (i = 1;i < 10;++i) fe_sq(t2,t2);
+
+/* qhasm: z_20_0 = z_20_10*z_10_0 */
+/* asm 1: fe_mul(>z_20_0=fe#3,<z_20_10=fe#3,<z_10_0=fe#2); */
+/* asm 2: fe_mul(>z_20_0=t2,<z_20_10=t2,<z_10_0=t1); */
+fe_mul(t2,t2,t1);
+
+/* qhasm: z_40_20 = z_20_0^2^20 */
+/* asm 1: fe_sq(>z_40_20=fe#4,<z_20_0=fe#3); for (i = 1;i < 20;++i) fe_sq(>z_40_20=fe#4,>z_40_20=fe#4); */
+/* asm 2: fe_sq(>z_40_20=t3,<z_20_0=t2); for (i = 1;i < 20;++i) fe_sq(>z_40_20=t3,>z_40_20=t3); */
+fe_sq(t3,t2); for (i = 1;i < 20;++i) fe_sq(t3,t3);
+
+/* qhasm: z_40_0 = z_40_20*z_20_0 */
+/* asm 1: fe_mul(>z_40_0=fe#3,<z_40_20=fe#4,<z_20_0=fe#3); */
+/* asm 2: fe_mul(>z_40_0=t2,<z_40_20=t3,<z_20_0=t2); */
+fe_mul(t2,t3,t2);
+
+/* qhasm: z_50_10 = z_40_0^2^10 */
+/* asm 1: fe_sq(>z_50_10=fe#3,<z_40_0=fe#3); for (i = 1;i < 10;++i) fe_sq(>z_50_10=fe#3,>z_50_10=fe#3); */
+/* asm 2: fe_sq(>z_50_10=t2,<z_40_0=t2); for (i = 1;i < 10;++i) fe_sq(>z_50_10=t2,>z_50_10=t2); */
+fe_sq(t2,t2); for (i = 1;i < 10;++i) fe_sq(t2,t2);
+
+/* qhasm: z_50_0 = z_50_10*z_10_0 */
+/* asm 1: fe_mul(>z_50_0=fe#2,<z_50_10=fe#3,<z_10_0=fe#2); */
+/* asm 2: fe_mul(>z_50_0=t1,<z_50_10=t2,<z_10_0=t1); */
+fe_mul(t1,t2,t1);
+
+/* qhasm: z_100_50 = z_50_0^2^50 */
+/* asm 1: fe_sq(>z_100_50=fe#3,<z_50_0=fe#2); for (i = 1;i < 50;++i) fe_sq(>z_100_50=fe#3,>z_100_50=fe#3); */
+/* asm 2: fe_sq(>z_100_50=t2,<z_50_0=t1); for (i = 1;i < 50;++i) fe_sq(>z_100_50=t2,>z_100_50=t2); */
+fe_sq(t2,t1); for (i = 1;i < 50;++i) fe_sq(t2,t2);
+
+/* qhasm: z_100_0 = z_100_50*z_50_0 */
+/* asm 1: fe_mul(>z_100_0=fe#3,<z_100_50=fe#3,<z_50_0=fe#2); */
+/* asm 2: fe_mul(>z_100_0=t2,<z_100_50=t2,<z_50_0=t1); */
+fe_mul(t2,t2,t1);
+
+/* qhasm: z_200_100 = z_100_0^2^100 */
+/* asm 1: fe_sq(>z_200_100=fe#4,<z_100_0=fe#3); for (i = 1;i < 100;++i) fe_sq(>z_200_100=fe#4,>z_200_100=fe#4); */
+/* asm 2: fe_sq(>z_200_100=t3,<z_100_0=t2); for (i = 1;i < 100;++i) fe_sq(>z_200_100=t3,>z_200_100=t3); */
+fe_sq(t3,t2); for (i = 1;i < 100;++i) fe_sq(t3,t3);
+
+/* qhasm: z_200_0 = z_200_100*z_100_0 */
+/* asm 1: fe_mul(>z_200_0=fe#3,<z_200_100=fe#4,<z_100_0=fe#3); */
+/* asm 2: fe_mul(>z_200_0=t2,<z_200_100=t3,<z_100_0=t2); */
+fe_mul(t2,t3,t2);
+
+/* qhasm: z_250_50 = z_200_0^2^50 */
+/* asm 1: fe_sq(>z_250_50=fe#3,<z_200_0=fe#3); for (i = 1;i < 50;++i) fe_sq(>z_250_50=fe#3,>z_250_50=fe#3); */
+/* asm 2: fe_sq(>z_250_50=t2,<z_200_0=t2); for (i = 1;i < 50;++i) fe_sq(>z_250_50=t2,>z_250_50=t2); */
+fe_sq(t2,t2); for (i = 1;i < 50;++i) fe_sq(t2,t2);
+
+/* qhasm: z_250_0 = z_250_50*z_50_0 */
+/* asm 1: fe_mul(>z_250_0=fe#2,<z_250_50=fe#3,<z_50_0=fe#2); */
+/* asm 2: fe_mul(>z_250_0=t1,<z_250_50=t2,<z_50_0=t1); */
+fe_mul(t1,t2,t1);
+
+/* qhasm: z_255_5 = z_250_0^2^5 */
+/* asm 1: fe_sq(>z_255_5=fe#2,<z_250_0=fe#2); for (i = 1;i < 5;++i) fe_sq(>z_255_5=fe#2,>z_255_5=fe#2); */
+/* asm 2: fe_sq(>z_255_5=t1,<z_250_0=t1); for (i = 1;i < 5;++i) fe_sq(>z_255_5=t1,>z_255_5=t1); */
+fe_sq(t1,t1); for (i = 1;i < 5;++i) fe_sq(t1,t1);
+
+/* qhasm: z_255_21 = z_255_5*z11 */
+/* asm 1: fe_mul(>z_255_21=fe#12,<z_255_5=fe#2,<z11=fe#1); */
+/* asm 2: fe_mul(>z_255_21=out,<z_255_5=t1,<z11=t0); */
+fe_mul(out,t1,t0);
+
+/* qhasm: return */
diff --git a/jni/ed25519/sc.h b/jni/ed25519/sc.h
new file mode 100644
index 00000000..d32ed2e8
--- /dev/null
+++ b/jni/ed25519/sc.h
@@ -0,0 +1,15 @@
+#ifndef SC_H
+#define SC_H
+
+/*
+The set of scalars is \Z/l
+where l = 2^252 + 27742317777372353535851937790883648493.
+*/
+
+#define sc_reduce crypto_sign_ed25519_ref10_sc_reduce
+#define sc_muladd crypto_sign_ed25519_ref10_sc_muladd
+
+extern void sc_reduce(unsigned char *);
+extern void sc_muladd(unsigned char *,const unsigned char *,const unsigned char *,const unsigned char *);
+
+#endif
diff --git a/jni/ed25519/sc_muladd.c b/jni/ed25519/sc_muladd.c
new file mode 100644
index 00000000..6f1e9d02
--- /dev/null
+++ b/jni/ed25519/sc_muladd.c
@@ -0,0 +1,368 @@
+#include "sc.h"
+#include "crypto_int64.h"
+#include "crypto_uint32.h"
+#include "crypto_uint64.h"
+
+static crypto_uint64 load_3(const unsigned char *in)
+{
+ crypto_uint64 result;
+ result = (crypto_uint64) in[0];
+ result |= ((crypto_uint64) in[1]) << 8;
+ result |= ((crypto_uint64) in[2]) << 16;
+ return result;
+}
+
+static crypto_uint64 load_4(const unsigned char *in)
+{
+ crypto_uint64 result;
+ result = (crypto_uint64) in[0];
+ result |= ((crypto_uint64) in[1]) << 8;
+ result |= ((crypto_uint64) in[2]) << 16;
+ result |= ((crypto_uint64) in[3]) << 24;
+ return result;
+}
+
+/*
+Input:
+ a[0]+256*a[1]+...+256^31*a[31] = a
+ b[0]+256*b[1]+...+256^31*b[31] = b
+ c[0]+256*c[1]+...+256^31*c[31] = c
+
+Output:
+ s[0]+256*s[1]+...+256^31*s[31] = (ab+c) mod l
+ where l = 2^252 + 27742317777372353535851937790883648493.
+*/
+
+void sc_muladd(unsigned char *s,const unsigned char *a,const unsigned char *b,const unsigned char *c)
+{
+ crypto_int64 a0 = 2097151 & load_3(a);
+ crypto_int64 a1 = 2097151 & (load_4(a + 2) >> 5);
+ crypto_int64 a2 = 2097151 & (load_3(a + 5) >> 2);
+ crypto_int64 a3 = 2097151 & (load_4(a + 7) >> 7);
+ crypto_int64 a4 = 2097151 & (load_4(a + 10) >> 4);
+ crypto_int64 a5 = 2097151 & (load_3(a + 13) >> 1);
+ crypto_int64 a6 = 2097151 & (load_4(a + 15) >> 6);
+ crypto_int64 a7 = 2097151 & (load_3(a + 18) >> 3);
+ crypto_int64 a8 = 2097151 & load_3(a + 21);
+ crypto_int64 a9 = 2097151 & (load_4(a + 23) >> 5);
+ crypto_int64 a10 = 2097151 & (load_3(a + 26) >> 2);
+ crypto_int64 a11 = (load_4(a + 28) >> 7);
+ crypto_int64 b0 = 2097151 & load_3(b);
+ crypto_int64 b1 = 2097151 & (load_4(b + 2) >> 5);
+ crypto_int64 b2 = 2097151 & (load_3(b + 5) >> 2);
+ crypto_int64 b3 = 2097151 & (load_4(b + 7) >> 7);
+ crypto_int64 b4 = 2097151 & (load_4(b + 10) >> 4);
+ crypto_int64 b5 = 2097151 & (load_3(b + 13) >> 1);
+ crypto_int64 b6 = 2097151 & (load_4(b + 15) >> 6);
+ crypto_int64 b7 = 2097151 & (load_3(b + 18) >> 3);
+ crypto_int64 b8 = 2097151 & load_3(b + 21);
+ crypto_int64 b9 = 2097151 & (load_4(b + 23) >> 5);
+ crypto_int64 b10 = 2097151 & (load_3(b + 26) >> 2);
+ crypto_int64 b11 = (load_4(b + 28) >> 7);
+ crypto_int64 c0 = 2097151 & load_3(c);
+ crypto_int64 c1 = 2097151 & (load_4(c + 2) >> 5);
+ crypto_int64 c2 = 2097151 & (load_3(c + 5) >> 2);
+ crypto_int64 c3 = 2097151 & (load_4(c + 7) >> 7);
+ crypto_int64 c4 = 2097151 & (load_4(c + 10) >> 4);
+ crypto_int64 c5 = 2097151 & (load_3(c + 13) >> 1);
+ crypto_int64 c6 = 2097151 & (load_4(c + 15) >> 6);
+ crypto_int64 c7 = 2097151 & (load_3(c + 18) >> 3);
+ crypto_int64 c8 = 2097151 & load_3(c + 21);
+ crypto_int64 c9 = 2097151 & (load_4(c + 23) >> 5);
+ crypto_int64 c10 = 2097151 & (load_3(c + 26) >> 2);
+ crypto_int64 c11 = (load_4(c + 28) >> 7);
+ crypto_int64 s0;
+ crypto_int64 s1;
+ crypto_int64 s2;
+ crypto_int64 s3;
+ crypto_int64 s4;
+ crypto_int64 s5;
+ crypto_int64 s6;
+ crypto_int64 s7;
+ crypto_int64 s8;
+ crypto_int64 s9;
+ crypto_int64 s10;
+ crypto_int64 s11;
+ crypto_int64 s12;
+ crypto_int64 s13;
+ crypto_int64 s14;
+ crypto_int64 s15;
+ crypto_int64 s16;
+ crypto_int64 s17;
+ crypto_int64 s18;
+ crypto_int64 s19;
+ crypto_int64 s20;
+ crypto_int64 s21;
+ crypto_int64 s22;
+ crypto_int64 s23;
+ crypto_int64 carry0;
+ crypto_int64 carry1;
+ crypto_int64 carry2;
+ crypto_int64 carry3;
+ crypto_int64 carry4;
+ crypto_int64 carry5;
+ crypto_int64 carry6;
+ crypto_int64 carry7;
+ crypto_int64 carry8;
+ crypto_int64 carry9;
+ crypto_int64 carry10;
+ crypto_int64 carry11;
+ crypto_int64 carry12;
+ crypto_int64 carry13;
+ crypto_int64 carry14;
+ crypto_int64 carry15;
+ crypto_int64 carry16;
+ crypto_int64 carry17;
+ crypto_int64 carry18;
+ crypto_int64 carry19;
+ crypto_int64 carry20;
+ crypto_int64 carry21;
+ crypto_int64 carry22;
+
+ s0 = c0 + a0*b0;
+ s1 = c1 + a0*b1 + a1*b0;
+ s2 = c2 + a0*b2 + a1*b1 + a2*b0;
+ s3 = c3 + a0*b3 + a1*b2 + a2*b1 + a3*b0;
+ s4 = c4 + a0*b4 + a1*b3 + a2*b2 + a3*b1 + a4*b0;
+ s5 = c5 + a0*b5 + a1*b4 + a2*b3 + a3*b2 + a4*b1 + a5*b0;
+ s6 = c6 + a0*b6 + a1*b5 + a2*b4 + a3*b3 + a4*b2 + a5*b1 + a6*b0;
+ s7 = c7 + a0*b7 + a1*b6 + a2*b5 + a3*b4 + a4*b3 + a5*b2 + a6*b1 + a7*b0;
+ s8 = c8 + a0*b8 + a1*b7 + a2*b6 + a3*b5 + a4*b4 + a5*b3 + a6*b2 + a7*b1 + a8*b0;
+ s9 = c9 + a0*b9 + a1*b8 + a2*b7 + a3*b6 + a4*b5 + a5*b4 + a6*b3 + a7*b2 + a8*b1 + a9*b0;
+ s10 = c10 + a0*b10 + a1*b9 + a2*b8 + a3*b7 + a4*b6 + a5*b5 + a6*b4 + a7*b3 + a8*b2 + a9*b1 + a10*b0;
+ s11 = c11 + a0*b11 + a1*b10 + a2*b9 + a3*b8 + a4*b7 + a5*b6 + a6*b5 + a7*b4 + a8*b3 + a9*b2 + a10*b1 + a11*b0;
+ s12 = a1*b11 + a2*b10 + a3*b9 + a4*b8 + a5*b7 + a6*b6 + a7*b5 + a8*b4 + a9*b3 + a10*b2 + a11*b1;
+ s13 = a2*b11 + a3*b10 + a4*b9 + a5*b8 + a6*b7 + a7*b6 + a8*b5 + a9*b4 + a10*b3 + a11*b2;
+ s14 = a3*b11 + a4*b10 + a5*b9 + a6*b8 + a7*b7 + a8*b6 + a9*b5 + a10*b4 + a11*b3;
+ s15 = a4*b11 + a5*b10 + a6*b9 + a7*b8 + a8*b7 + a9*b6 + a10*b5 + a11*b4;
+ s16 = a5*b11 + a6*b10 + a7*b9 + a8*b8 + a9*b7 + a10*b6 + a11*b5;
+ s17 = a6*b11 + a7*b10 + a8*b9 + a9*b8 + a10*b7 + a11*b6;
+ s18 = a7*b11 + a8*b10 + a9*b9 + a10*b8 + a11*b7;
+ s19 = a8*b11 + a9*b10 + a10*b9 + a11*b8;
+ s20 = a9*b11 + a10*b10 + a11*b9;
+ s21 = a10*b11 + a11*b10;
+ s22 = a11*b11;
+ s23 = 0;
+
+ carry0 = (s0 + (1<<20)) >> 21; s1 += carry0; s0 -= carry0 << 21;
+ carry2 = (s2 + (1<<20)) >> 21; s3 += carry2; s2 -= carry2 << 21;
+ carry4 = (s4 + (1<<20)) >> 21; s5 += carry4; s4 -= carry4 << 21;
+ carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
+ carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
+ carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
+ carry12 = (s12 + (1<<20)) >> 21; s13 += carry12; s12 -= carry12 << 21;
+ carry14 = (s14 + (1<<20)) >> 21; s15 += carry14; s14 -= carry14 << 21;
+ carry16 = (s16 + (1<<20)) >> 21; s17 += carry16; s16 -= carry16 << 21;
+ carry18 = (s18 + (1<<20)) >> 21; s19 += carry18; s18 -= carry18 << 21;
+ carry20 = (s20 + (1<<20)) >> 21; s21 += carry20; s20 -= carry20 << 21;
+ carry22 = (s22 + (1<<20)) >> 21; s23 += carry22; s22 -= carry22 << 21;
+
+ carry1 = (s1 + (1<<20)) >> 21; s2 += carry1; s1 -= carry1 << 21;
+ carry3 = (s3 + (1<<20)) >> 21; s4 += carry3; s3 -= carry3 << 21;
+ carry5 = (s5 + (1<<20)) >> 21; s6 += carry5; s5 -= carry5 << 21;
+ carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
+ carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
+ carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
+ carry13 = (s13 + (1<<20)) >> 21; s14 += carry13; s13 -= carry13 << 21;
+ carry15 = (s15 + (1<<20)) >> 21; s16 += carry15; s15 -= carry15 << 21;
+ carry17 = (s17 + (1<<20)) >> 21; s18 += carry17; s17 -= carry17 << 21;
+ carry19 = (s19 + (1<<20)) >> 21; s20 += carry19; s19 -= carry19 << 21;
+ carry21 = (s21 + (1<<20)) >> 21; s22 += carry21; s21 -= carry21 << 21;
+
+ s11 += s23 * 666643;
+ s12 += s23 * 470296;
+ s13 += s23 * 654183;
+ s14 -= s23 * 997805;
+ s15 += s23 * 136657;
+ s16 -= s23 * 683901;
+ s23 = 0;
+
+ s10 += s22 * 666643;
+ s11 += s22 * 470296;
+ s12 += s22 * 654183;
+ s13 -= s22 * 997805;
+ s14 += s22 * 136657;
+ s15 -= s22 * 683901;
+ s22 = 0;
+
+ s9 += s21 * 666643;
+ s10 += s21 * 470296;
+ s11 += s21 * 654183;
+ s12 -= s21 * 997805;
+ s13 += s21 * 136657;
+ s14 -= s21 * 683901;
+ s21 = 0;
+
+ s8 += s20 * 666643;
+ s9 += s20 * 470296;
+ s10 += s20 * 654183;
+ s11 -= s20 * 997805;
+ s12 += s20 * 136657;
+ s13 -= s20 * 683901;
+ s20 = 0;
+
+ s7 += s19 * 666643;
+ s8 += s19 * 470296;
+ s9 += s19 * 654183;
+ s10 -= s19 * 997805;
+ s11 += s19 * 136657;
+ s12 -= s19 * 683901;
+ s19 = 0;
+
+ s6 += s18 * 666643;
+ s7 += s18 * 470296;
+ s8 += s18 * 654183;
+ s9 -= s18 * 997805;
+ s10 += s18 * 136657;
+ s11 -= s18 * 683901;
+ s18 = 0;
+
+ carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
+ carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
+ carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
+ carry12 = (s12 + (1<<20)) >> 21; s13 += carry12; s12 -= carry12 << 21;
+ carry14 = (s14 + (1<<20)) >> 21; s15 += carry14; s14 -= carry14 << 21;
+ carry16 = (s16 + (1<<20)) >> 21; s17 += carry16; s16 -= carry16 << 21;
+
+ carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
+ carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
+ carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
+ carry13 = (s13 + (1<<20)) >> 21; s14 += carry13; s13 -= carry13 << 21;
+ carry15 = (s15 + (1<<20)) >> 21; s16 += carry15; s15 -= carry15 << 21;
+
+ s5 += s17 * 666643;
+ s6 += s17 * 470296;
+ s7 += s17 * 654183;
+ s8 -= s17 * 997805;
+ s9 += s17 * 136657;
+ s10 -= s17 * 683901;
+ s17 = 0;
+
+ s4 += s16 * 666643;
+ s5 += s16 * 470296;
+ s6 += s16 * 654183;
+ s7 -= s16 * 997805;
+ s8 += s16 * 136657;
+ s9 -= s16 * 683901;
+ s16 = 0;
+
+ s3 += s15 * 666643;
+ s4 += s15 * 470296;
+ s5 += s15 * 654183;
+ s6 -= s15 * 997805;
+ s7 += s15 * 136657;
+ s8 -= s15 * 683901;
+ s15 = 0;
+
+ s2 += s14 * 666643;
+ s3 += s14 * 470296;
+ s4 += s14 * 654183;
+ s5 -= s14 * 997805;
+ s6 += s14 * 136657;
+ s7 -= s14 * 683901;
+ s14 = 0;
+
+ s1 += s13 * 666643;
+ s2 += s13 * 470296;
+ s3 += s13 * 654183;
+ s4 -= s13 * 997805;
+ s5 += s13 * 136657;
+ s6 -= s13 * 683901;
+ s13 = 0;
+
+ s0 += s12 * 666643;
+ s1 += s12 * 470296;
+ s2 += s12 * 654183;
+ s3 -= s12 * 997805;
+ s4 += s12 * 136657;
+ s5 -= s12 * 683901;
+ s12 = 0;
+
+ carry0 = (s0 + (1<<20)) >> 21; s1 += carry0; s0 -= carry0 << 21;
+ carry2 = (s2 + (1<<20)) >> 21; s3 += carry2; s2 -= carry2 << 21;
+ carry4 = (s4 + (1<<20)) >> 21; s5 += carry4; s4 -= carry4 << 21;
+ carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
+ carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
+ carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
+
+ carry1 = (s1 + (1<<20)) >> 21; s2 += carry1; s1 -= carry1 << 21;
+ carry3 = (s3 + (1<<20)) >> 21; s4 += carry3; s3 -= carry3 << 21;
+ carry5 = (s5 + (1<<20)) >> 21; s6 += carry5; s5 -= carry5 << 21;
+ carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
+ carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
+ carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
+
+ s0 += s12 * 666643;
+ s1 += s12 * 470296;
+ s2 += s12 * 654183;
+ s3 -= s12 * 997805;
+ s4 += s12 * 136657;
+ s5 -= s12 * 683901;
+ s12 = 0;
+
+ carry0 = s0 >> 21; s1 += carry0; s0 -= carry0 << 21;
+ carry1 = s1 >> 21; s2 += carry1; s1 -= carry1 << 21;
+ carry2 = s2 >> 21; s3 += carry2; s2 -= carry2 << 21;
+ carry3 = s3 >> 21; s4 += carry3; s3 -= carry3 << 21;
+ carry4 = s4 >> 21; s5 += carry4; s4 -= carry4 << 21;
+ carry5 = s5 >> 21; s6 += carry5; s5 -= carry5 << 21;
+ carry6 = s6 >> 21; s7 += carry6; s6 -= carry6 << 21;
+ carry7 = s7 >> 21; s8 += carry7; s7 -= carry7 << 21;
+ carry8 = s8 >> 21; s9 += carry8; s8 -= carry8 << 21;
+ carry9 = s9 >> 21; s10 += carry9; s9 -= carry9 << 21;
+ carry10 = s10 >> 21; s11 += carry10; s10 -= carry10 << 21;
+ carry11 = s11 >> 21; s12 += carry11; s11 -= carry11 << 21;
+
+ s0 += s12 * 666643;
+ s1 += s12 * 470296;
+ s2 += s12 * 654183;
+ s3 -= s12 * 997805;
+ s4 += s12 * 136657;
+ s5 -= s12 * 683901;
+ s12 = 0;
+
+ carry0 = s0 >> 21; s1 += carry0; s0 -= carry0 << 21;
+ carry1 = s1 >> 21; s2 += carry1; s1 -= carry1 << 21;
+ carry2 = s2 >> 21; s3 += carry2; s2 -= carry2 << 21;
+ carry3 = s3 >> 21; s4 += carry3; s3 -= carry3 << 21;
+ carry4 = s4 >> 21; s5 += carry4; s4 -= carry4 << 21;
+ carry5 = s5 >> 21; s6 += carry5; s5 -= carry5 << 21;
+ carry6 = s6 >> 21; s7 += carry6; s6 -= carry6 << 21;
+ carry7 = s7 >> 21; s8 += carry7; s7 -= carry7 << 21;
+ carry8 = s8 >> 21; s9 += carry8; s8 -= carry8 << 21;
+ carry9 = s9 >> 21; s10 += carry9; s9 -= carry9 << 21;
+ carry10 = s10 >> 21; s11 += carry10; s10 -= carry10 << 21;
+
+ s[0] = s0 >> 0;
+ s[1] = s0 >> 8;
+ s[2] = (s0 >> 16) | (s1 << 5);
+ s[3] = s1 >> 3;
+ s[4] = s1 >> 11;
+ s[5] = (s1 >> 19) | (s2 << 2);
+ s[6] = s2 >> 6;
+ s[7] = (s2 >> 14) | (s3 << 7);
+ s[8] = s3 >> 1;
+ s[9] = s3 >> 9;
+ s[10] = (s3 >> 17) | (s4 << 4);
+ s[11] = s4 >> 4;
+ s[12] = s4 >> 12;
+ s[13] = (s4 >> 20) | (s5 << 1);
+ s[14] = s5 >> 7;
+ s[15] = (s5 >> 15) | (s6 << 6);
+ s[16] = s6 >> 2;
+ s[17] = s6 >> 10;
+ s[18] = (s6 >> 18) | (s7 << 3);
+ s[19] = s7 >> 5;
+ s[20] = s7 >> 13;
+ s[21] = s8 >> 0;
+ s[22] = s8 >> 8;
+ s[23] = (s8 >> 16) | (s9 << 5);
+ s[24] = s9 >> 3;
+ s[25] = s9 >> 11;
+ s[26] = (s9 >> 19) | (s10 << 2);
+ s[27] = s10 >> 6;
+ s[28] = (s10 >> 14) | (s11 << 7);
+ s[29] = s11 >> 1;
+ s[30] = s11 >> 9;
+ s[31] = s11 >> 17;
+}
diff --git a/jni/ed25519/sc_reduce.c b/jni/ed25519/sc_reduce.c
new file mode 100644
index 00000000..d01f5a57
--- /dev/null
+++ b/jni/ed25519/sc_reduce.c
@@ -0,0 +1,275 @@
+#include "sc.h"
+#include "crypto_int64.h"
+#include "crypto_uint32.h"
+#include "crypto_uint64.h"
+
+static crypto_uint64 load_3(const unsigned char *in)
+{
+ crypto_uint64 result;
+ result = (crypto_uint64) in[0];
+ result |= ((crypto_uint64) in[1]) << 8;
+ result |= ((crypto_uint64) in[2]) << 16;
+ return result;
+}
+
+static crypto_uint64 load_4(const unsigned char *in)
+{
+ crypto_uint64 result;
+ result = (crypto_uint64) in[0];
+ result |= ((crypto_uint64) in[1]) << 8;
+ result |= ((crypto_uint64) in[2]) << 16;
+ result |= ((crypto_uint64) in[3]) << 24;
+ return result;
+}
+
+/*
+Input:
+ s[0]+256*s[1]+...+256^63*s[63] = s
+
+Output:
+ s[0]+256*s[1]+...+256^31*s[31] = s mod l
+ where l = 2^252 + 27742317777372353535851937790883648493.
+ Overwrites s in place.
+*/
+
+void sc_reduce(unsigned char *s)
+{
+ crypto_int64 s0 = 2097151 & load_3(s);
+ crypto_int64 s1 = 2097151 & (load_4(s + 2) >> 5);
+ crypto_int64 s2 = 2097151 & (load_3(s + 5) >> 2);
+ crypto_int64 s3 = 2097151 & (load_4(s + 7) >> 7);
+ crypto_int64 s4 = 2097151 & (load_4(s + 10) >> 4);
+ crypto_int64 s5 = 2097151 & (load_3(s + 13) >> 1);
+ crypto_int64 s6 = 2097151 & (load_4(s + 15) >> 6);
+ crypto_int64 s7 = 2097151 & (load_3(s + 18) >> 3);
+ crypto_int64 s8 = 2097151 & load_3(s + 21);
+ crypto_int64 s9 = 2097151 & (load_4(s + 23) >> 5);
+ crypto_int64 s10 = 2097151 & (load_3(s + 26) >> 2);
+ crypto_int64 s11 = 2097151 & (load_4(s + 28) >> 7);
+ crypto_int64 s12 = 2097151 & (load_4(s + 31) >> 4);
+ crypto_int64 s13 = 2097151 & (load_3(s + 34) >> 1);
+ crypto_int64 s14 = 2097151 & (load_4(s + 36) >> 6);
+ crypto_int64 s15 = 2097151 & (load_3(s + 39) >> 3);
+ crypto_int64 s16 = 2097151 & load_3(s + 42);
+ crypto_int64 s17 = 2097151 & (load_4(s + 44) >> 5);
+ crypto_int64 s18 = 2097151 & (load_3(s + 47) >> 2);
+ crypto_int64 s19 = 2097151 & (load_4(s + 49) >> 7);
+ crypto_int64 s20 = 2097151 & (load_4(s + 52) >> 4);
+ crypto_int64 s21 = 2097151 & (load_3(s + 55) >> 1);
+ crypto_int64 s22 = 2097151 & (load_4(s + 57) >> 6);
+ crypto_int64 s23 = (load_4(s + 60) >> 3);
+ crypto_int64 carry0;
+ crypto_int64 carry1;
+ crypto_int64 carry2;
+ crypto_int64 carry3;
+ crypto_int64 carry4;
+ crypto_int64 carry5;
+ crypto_int64 carry6;
+ crypto_int64 carry7;
+ crypto_int64 carry8;
+ crypto_int64 carry9;
+ crypto_int64 carry10;
+ crypto_int64 carry11;
+ crypto_int64 carry12;
+ crypto_int64 carry13;
+ crypto_int64 carry14;
+ crypto_int64 carry15;
+ crypto_int64 carry16;
+
+ s11 += s23 * 666643;
+ s12 += s23 * 470296;
+ s13 += s23 * 654183;
+ s14 -= s23 * 997805;
+ s15 += s23 * 136657;
+ s16 -= s23 * 683901;
+ s23 = 0;
+
+ s10 += s22 * 666643;
+ s11 += s22 * 470296;
+ s12 += s22 * 654183;
+ s13 -= s22 * 997805;
+ s14 += s22 * 136657;
+ s15 -= s22 * 683901;
+ s22 = 0;
+
+ s9 += s21 * 666643;
+ s10 += s21 * 470296;
+ s11 += s21 * 654183;
+ s12 -= s21 * 997805;
+ s13 += s21 * 136657;
+ s14 -= s21 * 683901;
+ s21 = 0;
+
+ s8 += s20 * 666643;
+ s9 += s20 * 470296;
+ s10 += s20 * 654183;
+ s11 -= s20 * 997805;
+ s12 += s20 * 136657;
+ s13 -= s20 * 683901;
+ s20 = 0;
+
+ s7 += s19 * 666643;
+ s8 += s19 * 470296;
+ s9 += s19 * 654183;
+ s10 -= s19 * 997805;
+ s11 += s19 * 136657;
+ s12 -= s19 * 683901;
+ s19 = 0;
+
+ s6 += s18 * 666643;
+ s7 += s18 * 470296;
+ s8 += s18 * 654183;
+ s9 -= s18 * 997805;
+ s10 += s18 * 136657;
+ s11 -= s18 * 683901;
+ s18 = 0;
+
+ carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
+ carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
+ carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
+ carry12 = (s12 + (1<<20)) >> 21; s13 += carry12; s12 -= carry12 << 21;
+ carry14 = (s14 + (1<<20)) >> 21; s15 += carry14; s14 -= carry14 << 21;
+ carry16 = (s16 + (1<<20)) >> 21; s17 += carry16; s16 -= carry16 << 21;
+
+ carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
+ carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
+ carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
+ carry13 = (s13 + (1<<20)) >> 21; s14 += carry13; s13 -= carry13 << 21;
+ carry15 = (s15 + (1<<20)) >> 21; s16 += carry15; s15 -= carry15 << 21;
+
+ s5 += s17 * 666643;
+ s6 += s17 * 470296;
+ s7 += s17 * 654183;
+ s8 -= s17 * 997805;
+ s9 += s17 * 136657;
+ s10 -= s17 * 683901;
+ s17 = 0;
+
+ s4 += s16 * 666643;
+ s5 += s16 * 470296;
+ s6 += s16 * 654183;
+ s7 -= s16 * 997805;
+ s8 += s16 * 136657;
+ s9 -= s16 * 683901;
+ s16 = 0;
+
+ s3 += s15 * 666643;
+ s4 += s15 * 470296;
+ s5 += s15 * 654183;
+ s6 -= s15 * 997805;
+ s7 += s15 * 136657;
+ s8 -= s15 * 683901;
+ s15 = 0;
+
+ s2 += s14 * 666643;
+ s3 += s14 * 470296;
+ s4 += s14 * 654183;
+ s5 -= s14 * 997805;
+ s6 += s14 * 136657;
+ s7 -= s14 * 683901;
+ s14 = 0;
+
+ s1 += s13 * 666643;
+ s2 += s13 * 470296;
+ s3 += s13 * 654183;
+ s4 -= s13 * 997805;
+ s5 += s13 * 136657;
+ s6 -= s13 * 683901;
+ s13 = 0;
+
+ s0 += s12 * 666643;
+ s1 += s12 * 470296;
+ s2 += s12 * 654183;
+ s3 -= s12 * 997805;
+ s4 += s12 * 136657;
+ s5 -= s12 * 683901;
+ s12 = 0;
+
+ carry0 = (s0 + (1<<20)) >> 21; s1 += carry0; s0 -= carry0 << 21;
+ carry2 = (s2 + (1<<20)) >> 21; s3 += carry2; s2 -= carry2 << 21;
+ carry4 = (s4 + (1<<20)) >> 21; s5 += carry4; s4 -= carry4 << 21;
+ carry6 = (s6 + (1<<20)) >> 21; s7 += carry6; s6 -= carry6 << 21;
+ carry8 = (s8 + (1<<20)) >> 21; s9 += carry8; s8 -= carry8 << 21;
+ carry10 = (s10 + (1<<20)) >> 21; s11 += carry10; s10 -= carry10 << 21;
+
+ carry1 = (s1 + (1<<20)) >> 21; s2 += carry1; s1 -= carry1 << 21;
+ carry3 = (s3 + (1<<20)) >> 21; s4 += carry3; s3 -= carry3 << 21;
+ carry5 = (s5 + (1<<20)) >> 21; s6 += carry5; s5 -= carry5 << 21;
+ carry7 = (s7 + (1<<20)) >> 21; s8 += carry7; s7 -= carry7 << 21;
+ carry9 = (s9 + (1<<20)) >> 21; s10 += carry9; s9 -= carry9 << 21;
+ carry11 = (s11 + (1<<20)) >> 21; s12 += carry11; s11 -= carry11 << 21;
+
+ s0 += s12 * 666643;
+ s1 += s12 * 470296;
+ s2 += s12 * 654183;
+ s3 -= s12 * 997805;
+ s4 += s12 * 136657;
+ s5 -= s12 * 683901;
+ s12 = 0;
+
+ carry0 = s0 >> 21; s1 += carry0; s0 -= carry0 << 21;
+ carry1 = s1 >> 21; s2 += carry1; s1 -= carry1 << 21;
+ carry2 = s2 >> 21; s3 += carry2; s2 -= carry2 << 21;
+ carry3 = s3 >> 21; s4 += carry3; s3 -= carry3 << 21;
+ carry4 = s4 >> 21; s5 += carry4; s4 -= carry4 << 21;
+ carry5 = s5 >> 21; s6 += carry5; s5 -= carry5 << 21;
+ carry6 = s6 >> 21; s7 += carry6; s6 -= carry6 << 21;
+ carry7 = s7 >> 21; s8 += carry7; s7 -= carry7 << 21;
+ carry8 = s8 >> 21; s9 += carry8; s8 -= carry8 << 21;
+ carry9 = s9 >> 21; s10 += carry9; s9 -= carry9 << 21;
+ carry10 = s10 >> 21; s11 += carry10; s10 -= carry10 << 21;
+ carry11 = s11 >> 21; s12 += carry11; s11 -= carry11 << 21;
+
+ s0 += s12 * 666643;
+ s1 += s12 * 470296;
+ s2 += s12 * 654183;
+ s3 -= s12 * 997805;
+ s4 += s12 * 136657;
+ s5 -= s12 * 683901;
+ s12 = 0;
+
+ carry0 = s0 >> 21; s1 += carry0; s0 -= carry0 << 21;
+ carry1 = s1 >> 21; s2 += carry1; s1 -= carry1 << 21;
+ carry2 = s2 >> 21; s3 += carry2; s2 -= carry2 << 21;
+ carry3 = s3 >> 21; s4 += carry3; s3 -= carry3 << 21;
+ carry4 = s4 >> 21; s5 += carry4; s4 -= carry4 << 21;
+ carry5 = s5 >> 21; s6 += carry5; s5 -= carry5 << 21;
+ carry6 = s6 >> 21; s7 += carry6; s6 -= carry6 << 21;
+ carry7 = s7 >> 21; s8 += carry7; s7 -= carry7 << 21;
+ carry8 = s8 >> 21; s9 += carry8; s8 -= carry8 << 21;
+ carry9 = s9 >> 21; s10 += carry9; s9 -= carry9 << 21;
+ carry10 = s10 >> 21; s11 += carry10; s10 -= carry10 << 21;
+
+ s[0] = s0 >> 0;
+ s[1] = s0 >> 8;
+ s[2] = (s0 >> 16) | (s1 << 5);
+ s[3] = s1 >> 3;
+ s[4] = s1 >> 11;
+ s[5] = (s1 >> 19) | (s2 << 2);
+ s[6] = s2 >> 6;
+ s[7] = (s2 >> 14) | (s3 << 7);
+ s[8] = s3 >> 1;
+ s[9] = s3 >> 9;
+ s[10] = (s3 >> 17) | (s4 << 4);
+ s[11] = s4 >> 4;
+ s[12] = s4 >> 12;
+ s[13] = (s4 >> 20) | (s5 << 1);
+ s[14] = s5 >> 7;
+ s[15] = (s5 >> 15) | (s6 << 6);
+ s[16] = s6 >> 2;
+ s[17] = s6 >> 10;
+ s[18] = (s6 >> 18) | (s7 << 3);
+ s[19] = s7 >> 5;
+ s[20] = s7 >> 13;
+ s[21] = s8 >> 0;
+ s[22] = s8 >> 8;
+ s[23] = (s8 >> 16) | (s9 << 5);
+ s[24] = s9 >> 3;
+ s[25] = s9 >> 11;
+ s[26] = (s9 >> 19) | (s10 << 2);
+ s[27] = s10 >> 6;
+ s[28] = (s10 >> 14) | (s11 << 7);
+ s[29] = s11 >> 1;
+ s[30] = s11 >> 9;
+ s[31] = s11 >> 17;
+}
diff --git a/jni/ed25519/sign.c b/jni/ed25519/sign.c
new file mode 100644
index 00000000..de53742a
--- /dev/null
+++ b/jni/ed25519/sign.c
@@ -0,0 +1,41 @@
+#include <string.h>
+#include "crypto_sign.h"
+#include "crypto_hash_sha512.h"
+#include "ge.h"
+#include "sc.h"
+
+int crypto_sign(
+ unsigned char *sm,unsigned long long *smlen,
+ const unsigned char *m,unsigned long long mlen,
+ const unsigned char *sk
+)
+{
+ unsigned char pk[32];
+ unsigned char az[64];
+ unsigned char nonce[64];
+ unsigned char hram[64];
+ ge_p3 R;
+
+ memmove(pk,sk + 32,32);
+
+ crypto_hash_sha512(az,sk,32);
+ az[0] &= 248;
+ az[31] &= 63;
+ az[31] |= 64;
+
+ *smlen = mlen + 64;
+ memmove(sm + 64,m,mlen);
+ memmove(sm + 32,az + 32,32);
+ crypto_hash_sha512(nonce,sm + 32,mlen + 32);
+ memmove(sm + 32,pk,32);
+
+ sc_reduce(nonce);
+ ge_scalarmult_base(&R,nonce);
+ ge_p3_tobytes(sm,&R);
+
+ crypto_hash_sha512(hram,sm,mlen + 64);
+ sc_reduce(hram);
+ sc_muladd(sm + 32,hram,az,nonce);
+
+ return 0;
+}
diff --git a/jni/ed25519/sqrtm1.h b/jni/ed25519/sqrtm1.h
new file mode 100644
index 00000000..d8caa23b
--- /dev/null
+++ b/jni/ed25519/sqrtm1.h
@@ -0,0 +1 @@
+-32595792,-7943725,9377950,3500415,12389472,-272473,-25146209,-2005654,326686,11406482
diff --git a/libs/armeabi-v7a/libcurve25519.so b/libs/armeabi-v7a/libcurve25519.so
new file mode 100755
index 00000000..92bc5235
--- /dev/null
+++ b/libs/armeabi-v7a/libcurve25519.so
Binary files differ
diff --git a/libs/armeabi/libcurve25519.so b/libs/armeabi/libcurve25519.so
new file mode 100755
index 00000000..8fc5d8f2
--- /dev/null
+++ b/libs/armeabi/libcurve25519.so
Binary files differ
diff --git a/libs/mips/libcurve25519.so b/libs/mips/libcurve25519.so
new file mode 100755
index 00000000..b738852c
--- /dev/null
+++ b/libs/mips/libcurve25519.so
Binary files differ
diff --git a/libs/x86/libcurve25519.so b/libs/x86/libcurve25519.so
new file mode 100755
index 00000000..c06bd2b7
--- /dev/null
+++ b/libs/x86/libcurve25519.so
Binary files differ
diff --git a/protobuf/LocalStorageProtocol.proto b/protobuf/LocalStorageProtocol.proto
new file mode 100644
index 00000000..fb7c707b
--- /dev/null
+++ b/protobuf/LocalStorageProtocol.proto
@@ -0,0 +1,112 @@
+package textsecure;
+
+option java_package = "org.whispersystems.libaxolotl.state";
+option java_outer_classname = "StorageProtos";
+
+message SessionStructure {
+ message Chain {
+ optional bytes senderRatchetKey = 1;
+ optional bytes senderRatchetKeyPrivate = 2;
+
+ message ChainKey {
+ optional uint32 index = 1;
+ optional bytes key = 2;
+ }
+
+ optional ChainKey chainKey = 3;
+
+ message MessageKey {
+ optional uint32 index = 1;
+ optional bytes cipherKey = 2;
+ optional bytes macKey = 3;
+ optional bytes iv = 4;
+ }
+
+ repeated MessageKey messageKeys = 4;
+ }
+
+ message PendingKeyExchange {
+ optional uint32 sequence = 1;
+ optional bytes localBaseKey = 2;
+ optional bytes localBaseKeyPrivate = 3;
+ optional bytes localRatchetKey = 4;
+ optional bytes localRatchetKeyPrivate = 5;
+ optional bytes localIdentityKey = 7;
+ optional bytes localIdentityKeyPrivate = 8;
+ }
+
+ message PendingPreKey {
+ optional uint32 preKeyId = 1;
+ optional int32 signedPreKeyId = 3;
+ optional bytes baseKey = 2;
+ }
+
+ optional uint32 sessionVersion = 1;
+ optional bytes localIdentityPublic = 2;
+ optional bytes remoteIdentityPublic = 3;
+
+ optional bytes rootKey = 4;
+ optional uint32 previousCounter = 5;
+
+ optional Chain senderChain = 6;
+ repeated Chain receiverChains = 7;
+
+ optional PendingKeyExchange pendingKeyExchange = 8;
+ optional PendingPreKey pendingPreKey = 9;
+
+ optional uint32 remoteRegistrationId = 10;
+ optional uint32 localRegistrationId = 11;
+
+ optional bool needsRefresh = 12;
+ optional bytes aliceBaseKey = 13;
+}
+
+message RecordStructure {
+ optional SessionStructure currentSession = 1;
+ repeated SessionStructure previousSessions = 2;
+}
+
+message PreKeyRecordStructure {
+ optional uint32 id = 1;
+ optional bytes publicKey = 2;
+ optional bytes privateKey = 3;
+}
+
+message SignedPreKeyRecordStructure {
+ optional uint32 id = 1;
+ optional bytes publicKey = 2;
+ optional bytes privateKey = 3;
+ optional bytes signature = 4;
+ optional fixed64 timestamp = 5;
+}
+
+message IdentityKeyPairStructure {
+ optional bytes publicKey = 1;
+ optional bytes privateKey = 2;
+}
+
+message SenderKeyStateStructure {
+ message SenderChainKey {
+ optional uint32 iteration = 1;
+ optional bytes seed = 2;
+ }
+
+ message SenderMessageKey {
+ optional uint32 iteration = 1;
+ optional bytes seed = 2;
+ }
+
+ message SenderSigningKey {
+ optional bytes public = 1;
+ optional bytes private = 2;
+ }
+
+ optional uint32 senderKeyId = 1;
+ optional SenderChainKey senderChainKey = 2;
+ optional SenderSigningKey senderSigningKey = 3;
+ repeated SenderMessageKey senderMessageKeys = 4;
+}
+
+message SenderKeyRecordStructure {
+ repeated SenderKeyStateStructure senderKeyStates = 1;
+} \ No newline at end of file
diff --git a/protobuf/Makefile b/protobuf/Makefile
new file mode 100644
index 00000000..a57c1ee7
--- /dev/null
+++ b/protobuf/Makefile
@@ -0,0 +1,3 @@
+
+all:
+ protoc --java_out=../src/main/java/ WhisperTextProtocol.proto LocalStorageProtocol.proto
diff --git a/protobuf/WhisperTextProtocol.proto b/protobuf/WhisperTextProtocol.proto
new file mode 100644
index 00000000..7b4fe6ea
--- /dev/null
+++ b/protobuf/WhisperTextProtocol.proto
@@ -0,0 +1,41 @@
+package textsecure;
+
+option java_package = "org.whispersystems.libaxolotl.protocol";
+option java_outer_classname = "WhisperProtos";
+
+message WhisperMessage {
+ optional bytes ratchetKey = 1;
+ optional uint32 counter = 2;
+ optional uint32 previousCounter = 3;
+ optional bytes ciphertext = 4;
+}
+
+message PreKeyWhisperMessage {
+ optional uint32 registrationId = 5;
+ optional uint32 preKeyId = 1;
+ optional uint32 signedPreKeyId = 6;
+ optional bytes baseKey = 2;
+ optional bytes identityKey = 3;
+ optional bytes message = 4; // WhisperMessage
+}
+
+message KeyExchangeMessage {
+ optional uint32 id = 1;
+ optional bytes baseKey = 2;
+ optional bytes ratchetKey = 3;
+ optional bytes identityKey = 4;
+ optional bytes baseKeySignature = 5;
+}
+
+message SenderKeyMessage {
+ optional uint32 id = 1;
+ optional uint32 iteration = 2;
+ optional bytes ciphertext = 3;
+}
+
+message SenderKeyDistributionMessage {
+ optional uint32 id = 1;
+ optional uint32 iteration = 2;
+ optional bytes chainKey = 3;
+ optional bytes signingKey = 4;
+} \ No newline at end of file
diff --git a/src/androidTest/java/org/whispersystems/test/InMemoryAxolotlStore.java b/src/androidTest/java/org/whispersystems/test/InMemoryAxolotlStore.java
new file mode 100644
index 00000000..4e001865
--- /dev/null
+++ b/src/androidTest/java/org/whispersystems/test/InMemoryAxolotlStore.java
@@ -0,0 +1,115 @@
+package org.whispersystems.test;
+
+import org.whispersystems.libaxolotl.IdentityKey;
+import org.whispersystems.libaxolotl.IdentityKeyPair;
+import org.whispersystems.libaxolotl.InvalidKeyIdException;
+import org.whispersystems.libaxolotl.state.AxolotlStore;
+import org.whispersystems.libaxolotl.state.PreKeyRecord;
+import org.whispersystems.libaxolotl.state.SessionRecord;
+import org.whispersystems.libaxolotl.state.SignedPreKeyRecord;
+
+import java.util.List;
+
+public class InMemoryAxolotlStore implements AxolotlStore {
+
+ private final InMemoryIdentityKeyStore identityKeyStore = new InMemoryIdentityKeyStore();
+ private final InMemoryPreKeyStore preKeyStore = new InMemoryPreKeyStore();
+ private final InMemorySessionStore sessionStore = new InMemorySessionStore();
+ private final InMemorySignedPreKeyStore signedPreKeyStore = new InMemorySignedPreKeyStore();
+
+
+ @Override
+ public IdentityKeyPair getIdentityKeyPair() {
+ return identityKeyStore.getIdentityKeyPair();
+ }
+
+ @Override
+ public int getLocalRegistrationId() {
+ return identityKeyStore.getLocalRegistrationId();
+ }
+
+ @Override
+ public void saveIdentity(long recipientId, IdentityKey identityKey) {
+ identityKeyStore.saveIdentity(recipientId, identityKey);
+ }
+
+ @Override
+ public boolean isTrustedIdentity(long recipientId, IdentityKey identityKey) {
+ return identityKeyStore.isTrustedIdentity(recipientId, identityKey);
+ }
+
+ @Override
+ public PreKeyRecord loadPreKey(int preKeyId) throws InvalidKeyIdException {
+ return preKeyStore.loadPreKey(preKeyId);
+ }
+
+ @Override
+ public void storePreKey(int preKeyId, PreKeyRecord record) {
+ preKeyStore.storePreKey(preKeyId, record);
+ }
+
+ @Override
+ public boolean containsPreKey(int preKeyId) {
+ return preKeyStore.containsPreKey(preKeyId);
+ }
+
+ @Override
+ public void removePreKey(int preKeyId) {
+ preKeyStore.removePreKey(preKeyId);
+ }
+
+ @Override
+ public SessionRecord loadSession(long recipientId, int deviceId) {
+ return sessionStore.loadSession(recipientId, deviceId);
+ }
+
+ @Override
+ public List<Integer> getSubDeviceSessions(long recipientId) {
+ return sessionStore.getSubDeviceSessions(recipientId);
+ }
+
+ @Override
+ public void storeSession(long recipientId, int deviceId, SessionRecord record) {
+ sessionStore.storeSession(recipientId, deviceId, record);
+ }
+
+ @Override
+ public boolean containsSession(long recipientId, int deviceId) {
+ return sessionStore.containsSession(recipientId, deviceId);
+ }
+
+ @Override
+ public void deleteSession(long recipientId, int deviceId) {
+ sessionStore.deleteSession(recipientId, deviceId);
+ }
+
+ @Override
+ public void deleteAllSessions(long recipientId) {
+ sessionStore.deleteAllSessions(recipientId);
+ }
+
+ @Override
+ public SignedPreKeyRecord loadSignedPreKey(int signedPreKeyId) throws InvalidKeyIdException {
+ return signedPreKeyStore.loadSignedPreKey(signedPreKeyId);
+ }
+
+ @Override
+ public List<SignedPreKeyRecord> loadSignedPreKeys() {
+ return signedPreKeyStore.loadSignedPreKeys();
+ }
+
+ @Override
+ public void storeSignedPreKey(int signedPreKeyId, SignedPreKeyRecord record) {
+ signedPreKeyStore.storeSignedPreKey(signedPreKeyId, record);
+ }
+
+ @Override
+ public boolean containsSignedPreKey(int signedPreKeyId) {
+ return signedPreKeyStore.containsSignedPreKey(signedPreKeyId);
+ }
+
+ @Override
+ public void removeSignedPreKey(int signedPreKeyId) {
+ signedPreKeyStore.removeSignedPreKey(signedPreKeyId);
+ }
+}
diff --git a/src/androidTest/java/org/whispersystems/test/InMemoryIdentityKeyStore.java b/src/androidTest/java/org/whispersystems/test/InMemoryIdentityKeyStore.java
new file mode 100644
index 00000000..8a2e1d8f
--- /dev/null
+++ b/src/androidTest/java/org/whispersystems/test/InMemoryIdentityKeyStore.java
@@ -0,0 +1,53 @@
+package org.whispersystems.test;
+
+import org.whispersystems.libaxolotl.IdentityKey;
+import org.whispersystems.libaxolotl.IdentityKeyPair;
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.state.IdentityKeyStore;
+
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.util.HashMap;
+import java.util.Map;
+
+public class InMemoryIdentityKeyStore implements IdentityKeyStore {
+
+ private final Map<Long, IdentityKey> trustedKeys = new HashMap<>();
+
+ private final IdentityKeyPair identityKeyPair;
+ private final int localRegistrationId;
+
+ public InMemoryIdentityKeyStore() {
+ try {
+ ECKeyPair identityKeyPairKeys = Curve.generateKeyPair();
+
+ this.identityKeyPair = new IdentityKeyPair(new IdentityKey(identityKeyPairKeys.getPublicKey()),
+ identityKeyPairKeys.getPrivateKey());
+ this.localRegistrationId = SecureRandom.getInstance("SHA1PRNG").nextInt(16380) + 1;
+ } catch (NoSuchAlgorithmException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ @Override
+ public IdentityKeyPair getIdentityKeyPair() {
+ return identityKeyPair;
+ }
+
+ @Override
+ public int getLocalRegistrationId() {
+ return localRegistrationId;
+ }
+
+ @Override
+ public void saveIdentity(long recipientId, IdentityKey identityKey) {
+ trustedKeys.put(recipientId, identityKey);
+ }
+
+ @Override
+ public boolean isTrustedIdentity(long recipientId, IdentityKey identityKey) {
+ IdentityKey trusted = trustedKeys.get(recipientId);
+ return (trusted == null || trusted.equals(identityKey));
+ }
+}
diff --git a/src/androidTest/java/org/whispersystems/test/InMemoryPreKeyStore.java b/src/androidTest/java/org/whispersystems/test/InMemoryPreKeyStore.java
new file mode 100644
index 00000000..7c3cea08
--- /dev/null
+++ b/src/androidTest/java/org/whispersystems/test/InMemoryPreKeyStore.java
@@ -0,0 +1,42 @@
+package org.whispersystems.test;
+
+import org.whispersystems.libaxolotl.InvalidKeyIdException;
+import org.whispersystems.libaxolotl.state.PreKeyRecord;
+import org.whispersystems.libaxolotl.state.PreKeyStore;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+public class InMemoryPreKeyStore implements PreKeyStore {
+
+ private final Map<Integer, byte[]> store = new HashMap<>();
+
+ @Override
+ public PreKeyRecord loadPreKey(int preKeyId) throws InvalidKeyIdException {
+ try {
+ if (!store.containsKey(preKeyId)) {
+ throw new InvalidKeyIdException("No such prekeyrecord!");
+ }
+
+ return new PreKeyRecord(store.get(preKeyId));
+ } catch (IOException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ @Override
+ public void storePreKey(int preKeyId, PreKeyRecord record) {
+ store.put(preKeyId, record.serialize());
+ }
+
+ @Override
+ public boolean containsPreKey(int preKeyId) {
+ return store.containsKey(preKeyId);
+ }
+
+ @Override
+ public void removePreKey(int preKeyId) {
+ store.remove(preKeyId);
+ }
+}
diff --git a/src/androidTest/java/org/whispersystems/test/InMemorySessionStore.java b/src/androidTest/java/org/whispersystems/test/InMemorySessionStore.java
new file mode 100644
index 00000000..0d148ab0
--- /dev/null
+++ b/src/androidTest/java/org/whispersystems/test/InMemorySessionStore.java
@@ -0,0 +1,68 @@
+package org.whispersystems.test;
+
+import org.whispersystems.libaxolotl.state.SessionRecord;
+import org.whispersystems.libaxolotl.state.SessionStore;
+import org.whispersystems.libaxolotl.util.Pair;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+public class InMemorySessionStore implements SessionStore {
+
+ private Map<Pair<Long, Integer>, byte[]> sessions = new HashMap<>();
+
+ public InMemorySessionStore() {}
+
+ @Override
+ public synchronized SessionRecord loadSession(long recipientId, int deviceId) {
+ try {
+ if (containsSession(recipientId, deviceId)) {
+ return new SessionRecord(sessions.get(new Pair<>(recipientId, deviceId)));
+ } else {
+ return new SessionRecord();
+ }
+ } catch (IOException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ @Override
+ public synchronized List<Integer> getSubDeviceSessions(long recipientId) {
+ List<Integer> deviceIds = new LinkedList<>();
+
+ for (Pair<Long, Integer> key : sessions.keySet()) {
+ if (key.first() == recipientId) {
+ deviceIds.add(key.second());
+ }
+ }
+
+ return deviceIds;
+ }
+
+ @Override
+ public synchronized void storeSession(long recipientId, int deviceId, SessionRecord record) {
+ sessions.put(new Pair<>(recipientId, deviceId), record.serialize());
+ }
+
+ @Override
+ public synchronized boolean containsSession(long recipientId, int deviceId) {
+ return sessions.containsKey(new Pair<>(recipientId, deviceId));
+ }
+
+ @Override
+ public synchronized void deleteSession(long recipientId, int deviceId) {
+ sessions.remove(new Pair<>(recipientId, deviceId));
+ }
+
+ @Override
+ public synchronized void deleteAllSessions(long recipientId) {
+ for (Pair<Long, Integer> key : sessions.keySet()) {
+ if (key.first() == recipientId) {
+ sessions.remove(key);
+ }
+ }
+ }
+}
diff --git a/src/androidTest/java/org/whispersystems/test/InMemorySignedPreKeyStore.java b/src/androidTest/java/org/whispersystems/test/InMemorySignedPreKeyStore.java
new file mode 100644
index 00000000..7449eece
--- /dev/null
+++ b/src/androidTest/java/org/whispersystems/test/InMemorySignedPreKeyStore.java
@@ -0,0 +1,59 @@
+package org.whispersystems.test;
+
+import org.whispersystems.libaxolotl.InvalidKeyIdException;
+import org.whispersystems.libaxolotl.state.SignedPreKeyRecord;
+import org.whispersystems.libaxolotl.state.SignedPreKeyStore;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+public class InMemorySignedPreKeyStore implements SignedPreKeyStore {
+
+ private final Map<Integer, byte[]> store = new HashMap<>();
+
+ @Override
+ public SignedPreKeyRecord loadSignedPreKey(int signedPreKeyId) throws InvalidKeyIdException {
+ try {
+ if (!store.containsKey(signedPreKeyId)) {
+ throw new InvalidKeyIdException("No such signedprekeyrecord! " + signedPreKeyId);
+ }
+
+ return new SignedPreKeyRecord(store.get(signedPreKeyId));
+ } catch (IOException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ @Override
+ public List<SignedPreKeyRecord> loadSignedPreKeys() {
+ try {
+ List<SignedPreKeyRecord> results = new LinkedList<>();
+
+ for (byte[] serialized : store.values()) {
+ results.add(new SignedPreKeyRecord(serialized));
+ }
+
+ return results;
+ } catch (IOException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ @Override
+ public void storeSignedPreKey(int signedPreKeyId, SignedPreKeyRecord record) {
+ store.put(signedPreKeyId, record.serialize());
+ }
+
+ @Override
+ public boolean containsSignedPreKey(int signedPreKeyId) {
+ return store.containsKey(signedPreKeyId);
+ }
+
+ @Override
+ public void removeSignedPreKey(int signedPreKeyId) {
+ store.remove(signedPreKeyId);
+ }
+}
diff --git a/src/androidTest/java/org/whispersystems/test/SessionBuilderTest.java b/src/androidTest/java/org/whispersystems/test/SessionBuilderTest.java
new file mode 100644
index 00000000..802f401d
--- /dev/null
+++ b/src/androidTest/java/org/whispersystems/test/SessionBuilderTest.java
@@ -0,0 +1,601 @@
+package org.whispersystems.test;
+
+import android.test.AndroidTestCase;
+
+import org.whispersystems.libaxolotl.DuplicateMessageException;
+import org.whispersystems.libaxolotl.InvalidKeyException;
+import org.whispersystems.libaxolotl.InvalidKeyIdException;
+import org.whispersystems.libaxolotl.InvalidMessageException;
+import org.whispersystems.libaxolotl.InvalidVersionException;
+import org.whispersystems.libaxolotl.LegacyMessageException;
+import org.whispersystems.libaxolotl.NoSessionException;
+import org.whispersystems.libaxolotl.SessionBuilder;
+import org.whispersystems.libaxolotl.SessionCipher;
+import org.whispersystems.libaxolotl.StaleKeyExchangeException;
+import org.whispersystems.libaxolotl.UntrustedIdentityException;
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.protocol.CiphertextMessage;
+import org.whispersystems.libaxolotl.protocol.KeyExchangeMessage;
+import org.whispersystems.libaxolotl.protocol.PreKeyWhisperMessage;
+import org.whispersystems.libaxolotl.protocol.WhisperMessage;
+import org.whispersystems.libaxolotl.state.AxolotlStore;
+import org.whispersystems.libaxolotl.state.IdentityKeyStore;
+import org.whispersystems.libaxolotl.state.PreKeyBundle;
+import org.whispersystems.libaxolotl.state.PreKeyRecord;
+import org.whispersystems.libaxolotl.state.SignedPreKeyRecord;
+import org.whispersystems.libaxolotl.util.Pair;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class SessionBuilderTest extends AndroidTestCase {
+
+ private static final long ALICE_RECIPIENT_ID = 5L;
+ private static final long BOB_RECIPIENT_ID = 2L;
+
+ public void testBasicPreKeyV2()
+ throws InvalidKeyException, InvalidVersionException, InvalidMessageException, InvalidKeyIdException, DuplicateMessageException, LegacyMessageException, UntrustedIdentityException, NoSessionException {
+ AxolotlStore aliceStore = new InMemoryAxolotlStore();
+ SessionBuilder aliceSessionBuilder = new SessionBuilder(aliceStore, BOB_RECIPIENT_ID, 1);
+
+ AxolotlStore bobStore = new InMemoryAxolotlStore();
+ ECKeyPair bobPreKeyPair = Curve.generateKeyPair();
+ PreKeyBundle bobPreKey = new PreKeyBundle(bobStore.getLocalRegistrationId(), 1,
+ 31337, bobPreKeyPair.getPublicKey(),
+ 0, null, null,
+ bobStore.getIdentityKeyPair().getPublicKey());
+
+ aliceSessionBuilder.process(bobPreKey);
+
+ assertTrue(aliceStore.containsSession(BOB_RECIPIENT_ID, 1));
+ assertTrue(aliceStore.loadSession(BOB_RECIPIENT_ID, 1).getSessionState().getSessionVersion() == 2);
+
+ String originalMessage = "L'homme est condamné à être libre";
+ SessionCipher aliceSessionCipher = new SessionCipher(aliceStore, BOB_RECIPIENT_ID, 1);
+ CiphertextMessage outgoingMessage = aliceSessionCipher.encrypt(originalMessage.getBytes());
+
+ assertTrue(outgoingMessage.getType() == CiphertextMessage.PREKEY_TYPE);
+
+ PreKeyWhisperMessage incomingMessage = new PreKeyWhisperMessage(outgoingMessage.serialize());
+ bobStore.storePreKey(31337, new PreKeyRecord(bobPreKey.getPreKeyId(), bobPreKeyPair));
+
+ SessionCipher bobSessionCipher = new SessionCipher(bobStore, ALICE_RECIPIENT_ID, 1);
+ byte[] plaintext = bobSessionCipher.decrypt(incomingMessage);
+
+ assertTrue(bobStore.containsSession(ALICE_RECIPIENT_ID, 1));
+ assertTrue(bobStore.loadSession(ALICE_RECIPIENT_ID, 1).getSessionState().getSessionVersion() == 2);
+ assertTrue(originalMessage.equals(new String(plaintext)));
+
+ CiphertextMessage bobOutgoingMessage = bobSessionCipher.encrypt(originalMessage.getBytes());
+ assertTrue(bobOutgoingMessage.getType() == CiphertextMessage.WHISPER_TYPE);
+
+ byte[] alicePlaintext = aliceSessionCipher.decrypt((WhisperMessage)bobOutgoingMessage);
+ assertTrue(new String(alicePlaintext).equals(originalMessage));
+
+ runInteraction(aliceStore, bobStore);
+
+ aliceStore = new InMemoryAxolotlStore();
+ aliceSessionBuilder = new SessionBuilder(aliceStore, BOB_RECIPIENT_ID, 1);
+ aliceSessionCipher = new SessionCipher(aliceStore, BOB_RECIPIENT_ID, 1);
+
+ bobPreKeyPair = Curve.generateKeyPair();
+ bobPreKey = new PreKeyBundle(bobStore.getLocalRegistrationId(),
+ 1, 31338, bobPreKeyPair.getPublicKey(),
+ 0, null, null, bobStore.getIdentityKeyPair().getPublicKey());
+
+ bobStore.storePreKey(31338, new PreKeyRecord(bobPreKey.getPreKeyId(), bobPreKeyPair));
+ aliceSessionBuilder.process(bobPreKey);
+
+ outgoingMessage = aliceSessionCipher.encrypt(originalMessage.getBytes());
+
+ try {
+ bobSessionCipher.decrypt(new PreKeyWhisperMessage(outgoingMessage.serialize()));
+ throw new AssertionError("shouldn't be trusted!");
+ } catch (UntrustedIdentityException uie) {
+ bobStore.saveIdentity(ALICE_RECIPIENT_ID, new PreKeyWhisperMessage(outgoingMessage.serialize()).getIdentityKey());
+ }
+
+ plaintext = bobSessionCipher.decrypt(new PreKeyWhisperMessage(outgoingMessage.serialize()));
+
+ assertTrue(new String(plaintext).equals(originalMessage));
+
+ bobPreKey = new PreKeyBundle(bobStore.getLocalRegistrationId(), 1,
+ 31337, Curve.generateKeyPair().getPublicKey(),
+ 0, null, null,
+ aliceStore.getIdentityKeyPair().getPublicKey());
+
+ try {
+ aliceSessionBuilder.process(bobPreKey);
+ throw new AssertionError("shoulnd't be trusted!");
+ } catch (UntrustedIdentityException uie) {
+ // good
+ }
+ }
+
+ public void testBasicPreKeyV3()
+ throws InvalidKeyException, InvalidVersionException, InvalidMessageException, InvalidKeyIdException, DuplicateMessageException, LegacyMessageException, UntrustedIdentityException, NoSessionException {
+ AxolotlStore aliceStore = new InMemoryAxolotlStore();
+ SessionBuilder aliceSessionBuilder = new SessionBuilder(aliceStore, BOB_RECIPIENT_ID, 1);
+
+ final AxolotlStore bobStore = new InMemoryAxolotlStore();
+ ECKeyPair bobPreKeyPair = Curve.generateKeyPair();
+ ECKeyPair bobSignedPreKeyPair = Curve.generateKeyPair();
+ byte[] bobSignedPreKeySignature = Curve.calculateSignature(bobStore.getIdentityKeyPair().getPrivateKey(),
+ bobSignedPreKeyPair.getPublicKey().serialize());
+
+ PreKeyBundle bobPreKey = new PreKeyBundle(bobStore.getLocalRegistrationId(), 1,
+ 31337, bobPreKeyPair.getPublicKey(),
+ 22, bobSignedPreKeyPair.getPublicKey(),
+ bobSignedPreKeySignature,
+ bobStore.getIdentityKeyPair().getPublicKey());
+
+ aliceSessionBuilder.process(bobPreKey);
+
+ assertTrue(aliceStore.containsSession(BOB_RECIPIENT_ID, 1));
+ assertTrue(aliceStore.loadSession(BOB_RECIPIENT_ID, 1).getSessionState().getSessionVersion() == 3);
+
+ final String originalMessage = "L'homme est condamné à être libre";
+ SessionCipher aliceSessionCipher = new SessionCipher(aliceStore, BOB_RECIPIENT_ID, 1);
+ CiphertextMessage outgoingMessage = aliceSessionCipher.encrypt(originalMessage.getBytes());
+
+ assertTrue(outgoingMessage.getType() == CiphertextMessage.PREKEY_TYPE);
+
+ PreKeyWhisperMessage incomingMessage = new PreKeyWhisperMessage(outgoingMessage.serialize());
+ bobStore.storePreKey(31337, new PreKeyRecord(bobPreKey.getPreKeyId(), bobPreKeyPair));
+ bobStore.storeSignedPreKey(22, new SignedPreKeyRecord(22, System.currentTimeMillis(), bobSignedPreKeyPair, bobSignedPreKeySignature));
+
+ SessionCipher bobSessionCipher = new SessionCipher(bobStore, ALICE_RECIPIENT_ID, 1);
+ byte[] plaintext = bobSessionCipher.decrypt(incomingMessage, new SessionCipher.DecryptionCallback() {
+ @Override
+ public void handlePlaintext(byte[] plaintext) {
+ assertTrue(originalMessage.equals(new String(plaintext)));
+ assertFalse(bobStore.containsSession(ALICE_RECIPIENT_ID, 1));
+ }
+ });
+
+ assertTrue(bobStore.containsSession(ALICE_RECIPIENT_ID, 1));
+ assertTrue(bobStore.loadSession(ALICE_RECIPIENT_ID, 1).getSessionState().getSessionVersion() == 3);
+ assertTrue(bobStore.loadSession(ALICE_RECIPIENT_ID, 1).getSessionState().getAliceBaseKey() != null);
+ assertTrue(originalMessage.equals(new String(plaintext)));
+
+ CiphertextMessage bobOutgoingMessage = bobSessionCipher.encrypt(originalMessage.getBytes());
+ assertTrue(bobOutgoingMessage.getType() == CiphertextMessage.WHISPER_TYPE);
+
+ byte[] alicePlaintext = aliceSessionCipher.decrypt(new WhisperMessage(bobOutgoingMessage.serialize()));
+ assertTrue(new String(alicePlaintext).equals(originalMessage));
+
+ runInteraction(aliceStore, bobStore);
+
+ aliceStore = new InMemoryAxolotlStore();
+ aliceSessionBuilder = new SessionBuilder(aliceStore, BOB_RECIPIENT_ID, 1);
+ aliceSessionCipher = new SessionCipher(aliceStore, BOB_RECIPIENT_ID, 1);
+
+ bobPreKeyPair = Curve.generateKeyPair();
+ bobSignedPreKeyPair = Curve.generateKeyPair();
+ bobSignedPreKeySignature = Curve.calculateSignature(bobStore.getIdentityKeyPair().getPrivateKey(), bobSignedPreKeyPair.getPublicKey().serialize());
+ bobPreKey = new PreKeyBundle(bobStore.getLocalRegistrationId(),
+ 1, 31338, bobPreKeyPair.getPublicKey(),
+ 23, bobSignedPreKeyPair.getPublicKey(), bobSignedPreKeySignature,
+ bobStore.getIdentityKeyPair().getPublicKey());
+
+ bobStore.storePreKey(31338, new PreKeyRecord(bobPreKey.getPreKeyId(), bobPreKeyPair));
+ bobStore.storeSignedPreKey(23, new SignedPreKeyRecord(23, System.currentTimeMillis(), bobSignedPreKeyPair, bobSignedPreKeySignature));
+ aliceSessionBuilder.process(bobPreKey);
+
+ outgoingMessage = aliceSessionCipher.encrypt(originalMessage.getBytes());
+
+ try {
+ plaintext = bobSessionCipher.decrypt(new PreKeyWhisperMessage(outgoingMessage.serialize()));
+ throw new AssertionError("shouldn't be trusted!");
+ } catch (UntrustedIdentityException uie) {
+ bobStore.saveIdentity(ALICE_RECIPIENT_ID, new PreKeyWhisperMessage(outgoingMessage.serialize()).getIdentityKey());
+ }
+
+ plaintext = bobSessionCipher.decrypt(new PreKeyWhisperMessage(outgoingMessage.serialize()));
+ assertTrue(new String(plaintext).equals(originalMessage));
+
+ bobPreKey = new PreKeyBundle(bobStore.getLocalRegistrationId(), 1,
+ 31337, Curve.generateKeyPair().getPublicKey(),
+ 23, bobSignedPreKeyPair.getPublicKey(), bobSignedPreKeySignature,
+ aliceStore.getIdentityKeyPair().getPublicKey());
+
+ try {
+ aliceSessionBuilder.process(bobPreKey);
+ throw new AssertionError("shoulnd't be trusted!");
+ } catch (UntrustedIdentityException uie) {
+ // good
+ }
+ }
+
+ public void testBadSignedPreKeySignature() throws InvalidKeyException, UntrustedIdentityException {
+ AxolotlStore aliceStore = new InMemoryAxolotlStore();
+ SessionBuilder aliceSessionBuilder = new SessionBuilder(aliceStore, BOB_RECIPIENT_ID, 1);
+
+ IdentityKeyStore bobIdentityKeyStore = new InMemoryIdentityKeyStore();
+
+ ECKeyPair bobPreKeyPair = Curve.generateKeyPair();
+ ECKeyPair bobSignedPreKeyPair = Curve.generateKeyPair();
+ byte[] bobSignedPreKeySignature = Curve.calculateSignature(bobIdentityKeyStore.getIdentityKeyPair().getPrivateKey(),
+ bobSignedPreKeyPair.getPublicKey().serialize());
+
+
+ for (int i=0;i<bobSignedPreKeySignature.length * 8;i++) {
+ byte[] modifiedSignature = new byte[bobSignedPreKeySignature.length];
+ System.arraycopy(bobSignedPreKeySignature, 0, modifiedSignature, 0, modifiedSignature.length);
+
+ modifiedSignature[i/8] ^= (0x01 << (i % 8));
+
+ PreKeyBundle bobPreKey = new PreKeyBundle(bobIdentityKeyStore.getLocalRegistrationId(), 1,
+ 31337, bobPreKeyPair.getPublicKey(),
+ 22, bobSignedPreKeyPair.getPublicKey(), modifiedSignature,
+ bobIdentityKeyStore.getIdentityKeyPair().getPublicKey());
+
+ try {
+ aliceSessionBuilder.process(bobPreKey);
+ throw new AssertionError("Accepted modified device key signature!");
+ } catch (InvalidKeyException ike) {
+ // good
+ }
+ }
+
+ PreKeyBundle bobPreKey = new PreKeyBundle(bobIdentityKeyStore.getLocalRegistrationId(), 1,
+ 31337, bobPreKeyPair.getPublicKey(),
+ 22, bobSignedPreKeyPair.getPublicKey(), bobSignedPreKeySignature,
+ bobIdentityKeyStore.getIdentityKeyPair().getPublicKey());
+
+ aliceSessionBuilder.process(bobPreKey);
+ }
+
+ public void testRepeatBundleMessageV2() throws InvalidKeyException, UntrustedIdentityException, InvalidVersionException, InvalidMessageException, InvalidKeyIdException, DuplicateMessageException, LegacyMessageException, NoSessionException {
+ AxolotlStore aliceStore = new InMemoryAxolotlStore();
+ SessionBuilder aliceSessionBuilder = new SessionBuilder(aliceStore, BOB_RECIPIENT_ID, 1);
+
+ AxolotlStore bobStore = new InMemoryAxolotlStore();
+
+ ECKeyPair bobPreKeyPair = Curve.generateKeyPair();
+ ECKeyPair bobSignedPreKeyPair = Curve.generateKeyPair();
+ byte[] bobSignedPreKeySignature = Curve.calculateSignature(bobStore.getIdentityKeyPair().getPrivateKey(),
+ bobSignedPreKeyPair.getPublicKey().serialize());
+
+ PreKeyBundle bobPreKey = new PreKeyBundle(bobStore.getLocalRegistrationId(), 1,
+ 31337, bobPreKeyPair.getPublicKey(),
+ 0, null, null,
+ bobStore.getIdentityKeyPair().getPublicKey());
+
+ bobStore.storePreKey(31337, new PreKeyRecord(bobPreKey.getPreKeyId(), bobPreKeyPair));
+ bobStore.storeSignedPreKey(22, new SignedPreKeyRecord(22, System.currentTimeMillis(), bobSignedPreKeyPair, bobSignedPreKeySignature));
+
+ aliceSessionBuilder.process(bobPreKey);
+
+ String originalMessage = "L'homme est condamné à être libre";
+ SessionCipher aliceSessionCipher = new SessionCipher(aliceStore, BOB_RECIPIENT_ID, 1);
+ CiphertextMessage outgoingMessageOne = aliceSessionCipher.encrypt(originalMessage.getBytes());
+ CiphertextMessage outgoingMessageTwo = aliceSessionCipher.encrypt(originalMessage.getBytes());
+
+ assertTrue(outgoingMessageOne.getType() == CiphertextMessage.PREKEY_TYPE);
+
+ PreKeyWhisperMessage incomingMessage = new PreKeyWhisperMessage(outgoingMessageOne.serialize());
+
+ SessionCipher bobSessionCipher = new SessionCipher(bobStore, ALICE_RECIPIENT_ID, 1);
+
+ byte[] plaintext = bobSessionCipher.decrypt(incomingMessage);
+ assertTrue(originalMessage.equals(new String(plaintext)));
+
+ CiphertextMessage bobOutgoingMessage = bobSessionCipher.encrypt(originalMessage.getBytes());
+
+ byte[] alicePlaintext = aliceSessionCipher.decrypt(new WhisperMessage(bobOutgoingMessage.serialize()));
+ assertTrue(originalMessage.equals(new String(alicePlaintext)));
+
+ // The test
+
+ PreKeyWhisperMessage incomingMessageTwo = new PreKeyWhisperMessage(outgoingMessageTwo.serialize());
+
+ plaintext = bobSessionCipher.decrypt(incomingMessageTwo);
+ assertTrue(originalMessage.equals(new String(plaintext)));
+
+ bobOutgoingMessage = bobSessionCipher.encrypt(originalMessage.getBytes());
+ alicePlaintext = aliceSessionCipher.decrypt(new WhisperMessage(bobOutgoingMessage.serialize()));
+ assertTrue(originalMessage.equals(new String(alicePlaintext)));
+
+ }
+
+ public void testRepeatBundleMessageV3() throws InvalidKeyException, UntrustedIdentityException, InvalidVersionException, InvalidMessageException, InvalidKeyIdException, DuplicateMessageException, LegacyMessageException, NoSessionException {
+ AxolotlStore aliceStore = new InMemoryAxolotlStore();
+ SessionBuilder aliceSessionBuilder = new SessionBuilder(aliceStore, BOB_RECIPIENT_ID, 1);
+
+ AxolotlStore bobStore = new InMemoryAxolotlStore();
+
+ ECKeyPair bobPreKeyPair = Curve.generateKeyPair();
+ ECKeyPair bobSignedPreKeyPair = Curve.generateKeyPair();
+ byte[] bobSignedPreKeySignature = Curve.calculateSignature(bobStore.getIdentityKeyPair().getPrivateKey(),
+ bobSignedPreKeyPair.getPublicKey().serialize());
+
+ PreKeyBundle bobPreKey = new PreKeyBundle(bobStore.getLocalRegistrationId(), 1,
+ 31337, bobPreKeyPair.getPublicKey(),
+ 22, bobSignedPreKeyPair.getPublicKey(), bobSignedPreKeySignature,
+ bobStore.getIdentityKeyPair().getPublicKey());
+
+ bobStore.storePreKey(31337, new PreKeyRecord(bobPreKey.getPreKeyId(), bobPreKeyPair));
+ bobStore.storeSignedPreKey(22, new SignedPreKeyRecord(22, System.currentTimeMillis(), bobSignedPreKeyPair, bobSignedPreKeySignature));
+
+ aliceSessionBuilder.process(bobPreKey);
+
+ String originalMessage = "L'homme est condamné à être libre";
+ SessionCipher aliceSessionCipher = new SessionCipher(aliceStore, BOB_RECIPIENT_ID, 1);
+ CiphertextMessage outgoingMessageOne = aliceSessionCipher.encrypt(originalMessage.getBytes());
+ CiphertextMessage outgoingMessageTwo = aliceSessionCipher.encrypt(originalMessage.getBytes());
+
+ assertTrue(outgoingMessageOne.getType() == CiphertextMessage.PREKEY_TYPE);
+ assertTrue(outgoingMessageTwo.getType() == CiphertextMessage.PREKEY_TYPE);
+
+ PreKeyWhisperMessage incomingMessage = new PreKeyWhisperMessage(outgoingMessageOne.serialize());
+
+ SessionCipher bobSessionCipher = new SessionCipher(bobStore, ALICE_RECIPIENT_ID, 1);
+
+ byte[] plaintext = bobSessionCipher.decrypt(incomingMessage);
+ assertTrue(originalMessage.equals(new String(plaintext)));
+
+ CiphertextMessage bobOutgoingMessage = bobSessionCipher.encrypt(originalMessage.getBytes());
+
+ byte[] alicePlaintext = aliceSessionCipher.decrypt(new WhisperMessage(bobOutgoingMessage.serialize()));
+ assertTrue(originalMessage.equals(new String(alicePlaintext)));
+
+ // The test
+
+ PreKeyWhisperMessage incomingMessageTwo = new PreKeyWhisperMessage(outgoingMessageTwo.serialize());
+
+ plaintext = bobSessionCipher.decrypt(new PreKeyWhisperMessage(incomingMessageTwo.serialize()));
+ assertTrue(originalMessage.equals(new String(plaintext)));
+
+ bobOutgoingMessage = bobSessionCipher.encrypt(originalMessage.getBytes());
+ alicePlaintext = aliceSessionCipher.decrypt(new WhisperMessage(bobOutgoingMessage.serialize()));
+ assertTrue(originalMessage.equals(new String(alicePlaintext)));
+
+ }
+
+ public void testBadMessageBundle() throws InvalidKeyException, UntrustedIdentityException, InvalidVersionException, InvalidMessageException, DuplicateMessageException, LegacyMessageException, InvalidKeyIdException {
+ AxolotlStore aliceStore = new InMemoryAxolotlStore();
+ SessionBuilder aliceSessionBuilder = new SessionBuilder(aliceStore, BOB_RECIPIENT_ID, 1);
+
+ AxolotlStore bobStore = new InMemoryAxolotlStore();
+
+ ECKeyPair bobPreKeyPair = Curve.generateKeyPair();
+ ECKeyPair bobSignedPreKeyPair = Curve.generateKeyPair();
+ byte[] bobSignedPreKeySignature = Curve.calculateSignature(bobStore.getIdentityKeyPair().getPrivateKey(),
+ bobSignedPreKeyPair.getPublicKey().serialize());
+
+ PreKeyBundle bobPreKey = new PreKeyBundle(bobStore.getLocalRegistrationId(), 1,
+ 31337, bobPreKeyPair.getPublicKey(),
+ 22, bobSignedPreKeyPair.getPublicKey(), bobSignedPreKeySignature,
+ bobStore.getIdentityKeyPair().getPublicKey());
+
+ bobStore.storePreKey(31337, new PreKeyRecord(bobPreKey.getPreKeyId(), bobPreKeyPair));
+ bobStore.storeSignedPreKey(22, new SignedPreKeyRecord(22, System.currentTimeMillis(), bobSignedPreKeyPair, bobSignedPreKeySignature));
+
+ aliceSessionBuilder.process(bobPreKey);
+
+ String originalMessage = "L'homme est condamné à être libre";
+ SessionCipher aliceSessionCipher = new SessionCipher(aliceStore, BOB_RECIPIENT_ID, 1);
+ CiphertextMessage outgoingMessageOne = aliceSessionCipher.encrypt(originalMessage.getBytes());
+
+ assertTrue(outgoingMessageOne.getType() == CiphertextMessage.PREKEY_TYPE);
+
+ byte[] goodMessage = outgoingMessageOne.serialize();
+ byte[] badMessage = new byte[goodMessage.length];
+ System.arraycopy(goodMessage, 0, badMessage, 0, badMessage.length);
+
+ badMessage[badMessage.length-10] ^= 0x01;
+
+ PreKeyWhisperMessage incomingMessage = new PreKeyWhisperMessage(badMessage);
+ SessionCipher bobSessionCipher = new SessionCipher(bobStore, ALICE_RECIPIENT_ID, 1);
+
+ byte[] plaintext = new byte[0];
+
+ try {
+ plaintext = bobSessionCipher.decrypt(incomingMessage);
+ throw new AssertionError("Decrypt should have failed!");
+ } catch (InvalidMessageException e) {
+ // good.
+ }
+
+ assertTrue(bobStore.containsPreKey(31337));
+
+ plaintext = bobSessionCipher.decrypt(new PreKeyWhisperMessage(goodMessage));
+
+ assertTrue(originalMessage.equals(new String(plaintext)));
+ assertTrue(!bobStore.containsPreKey(31337));
+ }
+
+ public void testBasicKeyExchange() throws InvalidKeyException, LegacyMessageException, InvalidMessageException, DuplicateMessageException, UntrustedIdentityException, StaleKeyExchangeException, InvalidVersionException, NoSessionException {
+ AxolotlStore aliceStore = new InMemoryAxolotlStore();
+ SessionBuilder aliceSessionBuilder = new SessionBuilder(aliceStore, BOB_RECIPIENT_ID, 1);
+
+ AxolotlStore bobStore = new InMemoryAxolotlStore();
+ SessionBuilder bobSessionBuilder = new SessionBuilder(bobStore, ALICE_RECIPIENT_ID, 1);
+
+ KeyExchangeMessage aliceKeyExchangeMessage = aliceSessionBuilder.process();
+ assertTrue(aliceKeyExchangeMessage != null);
+
+ byte[] aliceKeyExchangeMessageBytes = aliceKeyExchangeMessage.serialize();
+ KeyExchangeMessage bobKeyExchangeMessage = bobSessionBuilder.process(new KeyExchangeMessage(aliceKeyExchangeMessageBytes));
+
+ assertTrue(bobKeyExchangeMessage != null);
+
+ byte[] bobKeyExchangeMessageBytes = bobKeyExchangeMessage.serialize();
+ KeyExchangeMessage response = aliceSessionBuilder.process(new KeyExchangeMessage(bobKeyExchangeMessageBytes));
+
+ assertTrue(response == null);
+ assertTrue(aliceStore.containsSession(BOB_RECIPIENT_ID, 1));
+ assertTrue(bobStore.containsSession(ALICE_RECIPIENT_ID, 1));
+
+ runInteraction(aliceStore, bobStore);
+
+ aliceStore = new InMemoryAxolotlStore();
+ aliceSessionBuilder = new SessionBuilder(aliceStore, BOB_RECIPIENT_ID, 1);
+ aliceKeyExchangeMessage = aliceSessionBuilder.process();
+
+ try {
+ bobKeyExchangeMessage = bobSessionBuilder.process(aliceKeyExchangeMessage);
+ throw new AssertionError("This identity shouldn't be trusted!");
+ } catch (UntrustedIdentityException uie) {
+ bobStore.saveIdentity(ALICE_RECIPIENT_ID, aliceKeyExchangeMessage.getIdentityKey());
+ bobKeyExchangeMessage = bobSessionBuilder.process(aliceKeyExchangeMessage);
+ }
+
+ assertTrue(aliceSessionBuilder.process(bobKeyExchangeMessage) == null);
+
+ runInteraction(aliceStore, bobStore);
+ }
+
+ public void testSimultaneousKeyExchange()
+ throws InvalidKeyException, DuplicateMessageException, LegacyMessageException, InvalidMessageException, UntrustedIdentityException, StaleKeyExchangeException, NoSessionException {
+ AxolotlStore aliceStore = new InMemoryAxolotlStore();
+ SessionBuilder aliceSessionBuilder = new SessionBuilder(aliceStore, BOB_RECIPIENT_ID, 1);
+
+ AxolotlStore bobStore = new InMemoryAxolotlStore();
+ SessionBuilder bobSessionBuilder = new SessionBuilder(bobStore, ALICE_RECIPIENT_ID, 1);
+
+ KeyExchangeMessage aliceKeyExchange = aliceSessionBuilder.process();
+ KeyExchangeMessage bobKeyExchange = bobSessionBuilder.process();
+
+ assertTrue(aliceKeyExchange != null);
+ assertTrue(bobKeyExchange != null);
+
+ KeyExchangeMessage aliceResponse = aliceSessionBuilder.process(bobKeyExchange);
+ KeyExchangeMessage bobResponse = bobSessionBuilder.process(aliceKeyExchange);
+
+ assertTrue(aliceResponse != null);
+ assertTrue(bobResponse != null);
+
+ KeyExchangeMessage aliceAck = aliceSessionBuilder.process(bobResponse);
+ KeyExchangeMessage bobAck = bobSessionBuilder.process(aliceResponse);
+
+ assertTrue(aliceAck == null);
+ assertTrue(bobAck == null);
+
+ runInteraction(aliceStore, bobStore);
+ }
+
+ public void testOptionalOneTimePreKey() throws Exception {
+ AxolotlStore aliceStore = new InMemoryAxolotlStore();
+ SessionBuilder aliceSessionBuilder = new SessionBuilder(aliceStore, BOB_RECIPIENT_ID, 1);
+
+ AxolotlStore bobStore = new InMemoryAxolotlStore();
+
+ ECKeyPair bobPreKeyPair = Curve.generateKeyPair();
+ ECKeyPair bobSignedPreKeyPair = Curve.generateKeyPair();
+ byte[] bobSignedPreKeySignature = Curve.calculateSignature(bobStore.getIdentityKeyPair().getPrivateKey(),
+ bobSignedPreKeyPair.getPublicKey().serialize());
+
+ PreKeyBundle bobPreKey = new PreKeyBundle(bobStore.getLocalRegistrationId(), 1,
+ 0, null,
+ 22, bobSignedPreKeyPair.getPublicKey(),
+ bobSignedPreKeySignature,
+ bobStore.getIdentityKeyPair().getPublicKey());
+
+ aliceSessionBuilder.process(bobPreKey);
+
+ assertTrue(aliceStore.containsSession(BOB_RECIPIENT_ID, 1));
+ assertTrue(aliceStore.loadSession(BOB_RECIPIENT_ID, 1).getSessionState().getSessionVersion() == 3);
+
+ String originalMessage = "L'homme est condamné à être libre";
+ SessionCipher aliceSessionCipher = new SessionCipher(aliceStore, BOB_RECIPIENT_ID, 1);
+ CiphertextMessage outgoingMessage = aliceSessionCipher.encrypt(originalMessage.getBytes());
+
+ assertTrue(outgoingMessage.getType() == CiphertextMessage.PREKEY_TYPE);
+
+ PreKeyWhisperMessage incomingMessage = new PreKeyWhisperMessage(outgoingMessage.serialize());
+ assertTrue(!incomingMessage.getPreKeyId().isPresent());
+
+ bobStore.storePreKey(31337, new PreKeyRecord(bobPreKey.getPreKeyId(), bobPreKeyPair));
+ bobStore.storeSignedPreKey(22, new SignedPreKeyRecord(22, System.currentTimeMillis(), bobSignedPreKeyPair, bobSignedPreKeySignature));
+
+ SessionCipher bobSessionCipher = new SessionCipher(bobStore, ALICE_RECIPIENT_ID, 1);
+ byte[] plaintext = bobSessionCipher.decrypt(incomingMessage);
+
+ assertTrue(bobStore.containsSession(ALICE_RECIPIENT_ID, 1));
+ assertTrue(bobStore.loadSession(ALICE_RECIPIENT_ID, 1).getSessionState().getSessionVersion() == 3);
+ assertTrue(bobStore.loadSession(ALICE_RECIPIENT_ID, 1).getSessionState().getAliceBaseKey() != null);
+ assertTrue(originalMessage.equals(new String(plaintext)));
+ }
+
+
+ private void runInteraction(AxolotlStore aliceStore, AxolotlStore bobStore)
+ throws DuplicateMessageException, LegacyMessageException, InvalidMessageException, NoSessionException
+ {
+ SessionCipher aliceSessionCipher = new SessionCipher(aliceStore, BOB_RECIPIENT_ID, 1);
+ SessionCipher bobSessionCipher = new SessionCipher(bobStore, ALICE_RECIPIENT_ID, 1);
+
+ String originalMessage = "smert ze smert";
+ CiphertextMessage aliceMessage = aliceSessionCipher.encrypt(originalMessage.getBytes());
+
+ assertTrue(aliceMessage.getType() == CiphertextMessage.WHISPER_TYPE);
+
+ byte[] plaintext = bobSessionCipher.decrypt(new WhisperMessage(aliceMessage.serialize()));
+ assertTrue(new String(plaintext).equals(originalMessage));
+
+ CiphertextMessage bobMessage = bobSessionCipher.encrypt(originalMessage.getBytes());
+
+ assertTrue(bobMessage.getType() == CiphertextMessage.WHISPER_TYPE);
+
+ plaintext = aliceSessionCipher.decrypt(new WhisperMessage(bobMessage.serialize()));
+ assertTrue(new String(plaintext).equals(originalMessage));
+
+ for (int i=0;i<10;i++) {
+ String loopingMessage = ("What do we mean by saying that existence precedes essence? " +
+ "We mean that man first of all exists, encounters himself, " +
+ "surges up in the world--and defines himself aftward. " + i);
+ CiphertextMessage aliceLoopingMessage = aliceSessionCipher.encrypt(loopingMessage.getBytes());
+
+ byte[] loopingPlaintext = bobSessionCipher.decrypt(new WhisperMessage(aliceLoopingMessage.serialize()));
+ assertTrue(new String(loopingPlaintext).equals(loopingMessage));
+ }
+
+ for (int i=0;i<10;i++) {
+ String loopingMessage = ("What do we mean by saying that existence precedes essence? " +
+ "We mean that man first of all exists, encounters himself, " +
+ "surges up in the world--and defines himself aftward. " + i);
+ CiphertextMessage bobLoopingMessage = bobSessionCipher.encrypt(loopingMessage.getBytes());
+
+ byte[] loopingPlaintext = aliceSessionCipher.decrypt(new WhisperMessage(bobLoopingMessage.serialize()));
+ assertTrue(new String(loopingPlaintext).equals(loopingMessage));
+ }
+
+ Set<Pair<String, CiphertextMessage>> aliceOutOfOrderMessages = new HashSet<>();
+
+ for (int i=0;i<10;i++) {
+ String loopingMessage = ("What do we mean by saying that existence precedes essence? " +
+ "We mean that man first of all exists, encounters himself, " +
+ "surges up in the world--and defines himself aftward. " + i);
+ CiphertextMessage aliceLoopingMessage = aliceSessionCipher.encrypt(loopingMessage.getBytes());
+
+ aliceOutOfOrderMessages.add(new Pair<>(loopingMessage, aliceLoopingMessage));
+ }
+
+ for (int i=0;i<10;i++) {
+ String loopingMessage = ("What do we mean by saying that existence precedes essence? " +
+ "We mean that man first of all exists, encounters himself, " +
+ "surges up in the world--and defines himself aftward. " + i);
+ CiphertextMessage aliceLoopingMessage = aliceSessionCipher.encrypt(loopingMessage.getBytes());
+
+ byte[] loopingPlaintext = bobSessionCipher.decrypt(new WhisperMessage(aliceLoopingMessage.serialize()));
+ assertTrue(new String(loopingPlaintext).equals(loopingMessage));
+ }
+
+ for (int i=0;i<10;i++) {
+ String loopingMessage = ("You can only desire based on what you know: " + i);
+ CiphertextMessage bobLoopingMessage = bobSessionCipher.encrypt(loopingMessage.getBytes());
+
+ byte[] loopingPlaintext = aliceSessionCipher.decrypt(new WhisperMessage(bobLoopingMessage.serialize()));
+ assertTrue(new String(loopingPlaintext).equals(loopingMessage));
+ }
+
+ for (Pair<String, CiphertextMessage> aliceOutOfOrderMessage : aliceOutOfOrderMessages) {
+ byte[] outOfOrderPlaintext = bobSessionCipher.decrypt(new WhisperMessage(aliceOutOfOrderMessage.second().serialize()));
+ assertTrue(new String(outOfOrderPlaintext).equals(aliceOutOfOrderMessage.first()));
+ }
+ }
+
+
+}
diff --git a/src/androidTest/java/org/whispersystems/test/SessionCipherTest.java b/src/androidTest/java/org/whispersystems/test/SessionCipherTest.java
new file mode 100644
index 00000000..52b5fa89
--- /dev/null
+++ b/src/androidTest/java/org/whispersystems/test/SessionCipherTest.java
@@ -0,0 +1,206 @@
+package org.whispersystems.test;
+
+import android.test.AndroidTestCase;
+
+import org.whispersystems.libaxolotl.DuplicateMessageException;
+import org.whispersystems.libaxolotl.IdentityKey;
+import org.whispersystems.libaxolotl.IdentityKeyPair;
+import org.whispersystems.libaxolotl.InvalidKeyException;
+import org.whispersystems.libaxolotl.InvalidMessageException;
+import org.whispersystems.libaxolotl.LegacyMessageException;
+import org.whispersystems.libaxolotl.NoSessionException;
+import org.whispersystems.libaxolotl.SessionCipher;
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+import org.whispersystems.libaxolotl.protocol.CiphertextMessage;
+import org.whispersystems.libaxolotl.protocol.WhisperMessage;
+import org.whispersystems.libaxolotl.ratchet.AliceAxolotlParameters;
+import org.whispersystems.libaxolotl.ratchet.BobAxolotlParameters;
+import org.whispersystems.libaxolotl.ratchet.RatchetingSession;
+import org.whispersystems.libaxolotl.state.AxolotlStore;
+import org.whispersystems.libaxolotl.state.SessionRecord;
+import org.whispersystems.libaxolotl.state.SessionState;
+import org.whispersystems.libaxolotl.util.guava.Optional;
+
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+
+
+public class SessionCipherTest extends AndroidTestCase {
+
+ public void testBasicSessionV2()
+ throws InvalidKeyException, DuplicateMessageException,
+ LegacyMessageException, InvalidMessageException, NoSuchAlgorithmException, NoSessionException
+ {
+ SessionRecord aliceSessionRecord = new SessionRecord();
+ SessionRecord bobSessionRecord = new SessionRecord();
+
+ initializeSessionsV2(aliceSessionRecord.getSessionState(), bobSessionRecord.getSessionState());
+ runInteraction(aliceSessionRecord, bobSessionRecord);
+ }
+
+ public void testBasicSessionV3()
+ throws InvalidKeyException, DuplicateMessageException,
+ LegacyMessageException, InvalidMessageException, NoSuchAlgorithmException, NoSessionException
+ {
+ SessionRecord aliceSessionRecord = new SessionRecord();
+ SessionRecord bobSessionRecord = new SessionRecord();
+
+ initializeSessionsV3(aliceSessionRecord.getSessionState(), bobSessionRecord.getSessionState());
+ runInteraction(aliceSessionRecord, bobSessionRecord);
+ }
+
+ private void runInteraction(SessionRecord aliceSessionRecord, SessionRecord bobSessionRecord)
+ throws DuplicateMessageException, LegacyMessageException, InvalidMessageException, NoSuchAlgorithmException, NoSessionException {
+ AxolotlStore aliceStore = new InMemoryAxolotlStore();
+ AxolotlStore bobStore = new InMemoryAxolotlStore();
+
+ aliceStore.storeSession(2L, 1, aliceSessionRecord);
+ bobStore.storeSession(3L, 1, bobSessionRecord);
+
+ SessionCipher aliceCipher = new SessionCipher(aliceStore, 2L, 1);
+ SessionCipher bobCipher = new SessionCipher(bobStore, 3L, 1);
+
+ byte[] alicePlaintext = "This is a plaintext message.".getBytes();
+ CiphertextMessage message = aliceCipher.encrypt(alicePlaintext);
+ byte[] bobPlaintext = bobCipher.decrypt(new WhisperMessage(message.serialize()));
+
+ assertTrue(Arrays.equals(alicePlaintext, bobPlaintext));
+
+ byte[] bobReply = "This is a message from Bob.".getBytes();
+ CiphertextMessage reply = bobCipher.encrypt(bobReply);
+ byte[] receivedReply = aliceCipher.decrypt(new WhisperMessage(reply.serialize()));
+
+ assertTrue(Arrays.equals(bobReply, receivedReply));
+
+ List<CiphertextMessage> aliceCiphertextMessages = new ArrayList<>();
+ List<byte[]> alicePlaintextMessages = new ArrayList<>();
+
+ for (int i=0;i<50;i++) {
+ alicePlaintextMessages.add(("смерть за смерть " + i).getBytes());
+ aliceCiphertextMessages.add(aliceCipher.encrypt(("смерть за смерть " + i).getBytes()));
+ }
+
+ long seed = System.currentTimeMillis();
+
+ Collections.shuffle(aliceCiphertextMessages, new Random(seed));
+ Collections.shuffle(alicePlaintextMessages, new Random(seed));
+
+ for (int i=0;i<aliceCiphertextMessages.size() / 2;i++) {
+ byte[] receivedPlaintext = bobCipher.decrypt(new WhisperMessage(aliceCiphertextMessages.get(i).serialize()));
+ assertTrue(Arrays.equals(receivedPlaintext, alicePlaintextMessages.get(i)));
+ }
+
+ List<CiphertextMessage> bobCiphertextMessages = new ArrayList<>();
+ List<byte[]> bobPlaintextMessages = new ArrayList<>();
+
+ for (int i=0;i<20;i++) {
+ bobPlaintextMessages.add(("смерть за смерть " + i).getBytes());
+ bobCiphertextMessages.add(bobCipher.encrypt(("смерть за смерть " + i).getBytes()));
+ }
+
+ seed = System.currentTimeMillis();
+
+ Collections.shuffle(bobCiphertextMessages, new Random(seed));
+ Collections.shuffle(bobPlaintextMessages, new Random(seed));
+
+ for (int i=0;i<bobCiphertextMessages.size() / 2;i++) {
+ byte[] receivedPlaintext = aliceCipher.decrypt(new WhisperMessage(bobCiphertextMessages.get(i).serialize()));
+ assertTrue(Arrays.equals(receivedPlaintext, bobPlaintextMessages.get(i)));
+ }
+
+ for (int i=aliceCiphertextMessages.size()/2;i<aliceCiphertextMessages.size();i++) {
+ byte[] receivedPlaintext = bobCipher.decrypt(new WhisperMessage(aliceCiphertextMessages.get(i).serialize()));
+ assertTrue(Arrays.equals(receivedPlaintext, alicePlaintextMessages.get(i)));
+ }
+
+ for (int i=bobCiphertextMessages.size() / 2;i<bobCiphertextMessages.size();i++) {
+ byte[] receivedPlaintext = aliceCipher.decrypt(new WhisperMessage(bobCiphertextMessages.get(i).serialize()));
+ assertTrue(Arrays.equals(receivedPlaintext, bobPlaintextMessages.get(i)));
+ }
+ }
+
+
+ private void initializeSessionsV2(SessionState aliceSessionState, SessionState bobSessionState)
+ throws InvalidKeyException
+ {
+ ECKeyPair aliceIdentityKeyPair = Curve.generateKeyPair();
+ IdentityKeyPair aliceIdentityKey = new IdentityKeyPair(new IdentityKey(aliceIdentityKeyPair.getPublicKey()),
+ aliceIdentityKeyPair.getPrivateKey());
+ ECKeyPair aliceBaseKey = Curve.generateKeyPair();
+ ECKeyPair aliceEphemeralKey = Curve.generateKeyPair();
+
+ ECKeyPair bobIdentityKeyPair = Curve.generateKeyPair();
+ IdentityKeyPair bobIdentityKey = new IdentityKeyPair(new IdentityKey(bobIdentityKeyPair.getPublicKey()),
+ bobIdentityKeyPair.getPrivateKey());
+ ECKeyPair bobBaseKey = Curve.generateKeyPair();
+ ECKeyPair bobEphemeralKey = bobBaseKey;
+
+ AliceAxolotlParameters aliceParameters = AliceAxolotlParameters.newBuilder()
+ .setOurIdentityKey(aliceIdentityKey)
+ .setOurBaseKey(aliceBaseKey)
+ .setTheirIdentityKey(bobIdentityKey.getPublicKey())
+ .setTheirSignedPreKey(bobEphemeralKey.getPublicKey())
+ .setTheirRatchetKey(bobEphemeralKey.getPublicKey())
+ .setTheirOneTimePreKey(Optional.<ECPublicKey>absent())
+ .create();
+
+ BobAxolotlParameters bobParameters = BobAxolotlParameters.newBuilder()
+ .setOurIdentityKey(bobIdentityKey)
+ .setOurOneTimePreKey(Optional.<ECKeyPair>absent())
+ .setOurRatchetKey(bobEphemeralKey)
+ .setOurSignedPreKey(bobBaseKey)
+ .setTheirBaseKey(aliceBaseKey.getPublicKey())
+ .setTheirIdentityKey(aliceIdentityKey.getPublicKey())
+ .create();
+
+ RatchetingSession.initializeSession(aliceSessionState, 2, aliceParameters);
+ RatchetingSession.initializeSession(bobSessionState, 2, bobParameters);
+ }
+
+ private void initializeSessionsV3(SessionState aliceSessionState, SessionState bobSessionState)
+ throws InvalidKeyException
+ {
+ ECKeyPair aliceIdentityKeyPair = Curve.generateKeyPair();
+ IdentityKeyPair aliceIdentityKey = new IdentityKeyPair(new IdentityKey(aliceIdentityKeyPair.getPublicKey()),
+ aliceIdentityKeyPair.getPrivateKey());
+ ECKeyPair aliceBaseKey = Curve.generateKeyPair();
+ ECKeyPair aliceEphemeralKey = Curve.generateKeyPair();
+
+ ECKeyPair alicePreKey = aliceBaseKey;
+
+ ECKeyPair bobIdentityKeyPair = Curve.generateKeyPair();
+ IdentityKeyPair bobIdentityKey = new IdentityKeyPair(new IdentityKey(bobIdentityKeyPair.getPublicKey()),
+ bobIdentityKeyPair.getPrivateKey());
+ ECKeyPair bobBaseKey = Curve.generateKeyPair();
+ ECKeyPair bobEphemeralKey = bobBaseKey;
+
+ ECKeyPair bobPreKey = Curve.generateKeyPair();
+
+ AliceAxolotlParameters aliceParameters = AliceAxolotlParameters.newBuilder()
+ .setOurBaseKey(aliceBaseKey)
+ .setOurIdentityKey(aliceIdentityKey)
+ .setTheirOneTimePreKey(Optional.<ECPublicKey>absent())
+ .setTheirRatchetKey(bobEphemeralKey.getPublicKey())
+ .setTheirSignedPreKey(bobBaseKey.getPublicKey())
+ .setTheirIdentityKey(bobIdentityKey.getPublicKey())
+ .create();
+
+ BobAxolotlParameters bobParameters = BobAxolotlParameters.newBuilder()
+ .setOurRatchetKey(bobEphemeralKey)
+ .setOurSignedPreKey(bobBaseKey)
+ .setOurOneTimePreKey(Optional.<ECKeyPair>absent())
+ .setOurIdentityKey(bobIdentityKey)
+ .setTheirIdentityKey(aliceIdentityKey.getPublicKey())
+ .setTheirBaseKey(aliceBaseKey.getPublicKey())
+ .create();
+
+ RatchetingSession.initializeSession(aliceSessionState, 3, aliceParameters);
+ RatchetingSession.initializeSession(bobSessionState, 3, bobParameters);
+ }
+}
diff --git a/src/androidTest/java/org/whispersystems/test/SimultaneousInitiateTests.java b/src/androidTest/java/org/whispersystems/test/SimultaneousInitiateTests.java
new file mode 100644
index 00000000..dffde57c
--- /dev/null
+++ b/src/androidTest/java/org/whispersystems/test/SimultaneousInitiateTests.java
@@ -0,0 +1,501 @@
+package org.whispersystems.test;
+
+import android.test.AndroidTestCase;
+import android.util.Log;
+
+import org.whispersystems.libaxolotl.DuplicateMessageException;
+import org.whispersystems.libaxolotl.InvalidKeyException;
+import org.whispersystems.libaxolotl.InvalidKeyIdException;
+import org.whispersystems.libaxolotl.InvalidMessageException;
+import org.whispersystems.libaxolotl.InvalidVersionException;
+import org.whispersystems.libaxolotl.LegacyMessageException;
+import org.whispersystems.libaxolotl.NoSessionException;
+import org.whispersystems.libaxolotl.SessionBuilder;
+import org.whispersystems.libaxolotl.SessionCipher;
+import org.whispersystems.libaxolotl.UntrustedIdentityException;
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.protocol.CiphertextMessage;
+import org.whispersystems.libaxolotl.protocol.PreKeyWhisperMessage;
+import org.whispersystems.libaxolotl.protocol.WhisperMessage;
+import org.whispersystems.libaxolotl.state.AxolotlStore;
+import org.whispersystems.libaxolotl.state.PreKeyBundle;
+import org.whispersystems.libaxolotl.state.PreKeyRecord;
+import org.whispersystems.libaxolotl.state.SignedPreKeyRecord;
+import org.whispersystems.libaxolotl.util.Medium;
+
+import java.util.Arrays;
+import java.util.Random;
+
+public class SimultaneousInitiateTests extends AndroidTestCase {
+
+ private static final long BOB_RECIPENT_ID = 12345;
+ private static final long ALICE_RECIPIENT_ID = 6789;
+
+ private static final ECKeyPair aliceSignedPreKey = Curve.generateKeyPair();
+ private static final ECKeyPair bobSignedPreKey = Curve.generateKeyPair();
+
+ private static final int aliceSignedPreKeyId = new Random().nextInt(Medium.MAX_VALUE);
+ private static final int bobSignedPreKeyId = new Random().nextInt(Medium.MAX_VALUE);
+
+ public void testBasicSimultaneousInitiate()
+ throws InvalidKeyException, UntrustedIdentityException, InvalidVersionException,
+ InvalidMessageException, DuplicateMessageException, LegacyMessageException,
+ InvalidKeyIdException, NoSessionException
+ {
+ AxolotlStore aliceStore = new InMemoryAxolotlStore();
+ AxolotlStore bobStore = new InMemoryAxolotlStore();
+
+ PreKeyBundle alicePreKeyBundle = createAlicePreKeyBundle(aliceStore);
+ PreKeyBundle bobPreKeyBundle = createBobPreKeyBundle(bobStore);
+
+ SessionBuilder aliceSessionBuilder = new SessionBuilder(aliceStore, BOB_RECIPENT_ID, 1);
+ SessionBuilder bobSessionBuilder = new SessionBuilder(bobStore, ALICE_RECIPIENT_ID, 1);
+
+ SessionCipher aliceSessionCipher = new SessionCipher(aliceStore, BOB_RECIPENT_ID, 1);
+ SessionCipher bobSessionCipher = new SessionCipher(bobStore, ALICE_RECIPIENT_ID, 1);
+
+ aliceSessionBuilder.process(bobPreKeyBundle);
+ bobSessionBuilder.process(alicePreKeyBundle);
+
+ CiphertextMessage messageForBob = aliceSessionCipher.encrypt("hey there".getBytes());
+ CiphertextMessage messageForAlice = bobSessionCipher.encrypt("sample message".getBytes());
+
+ assertTrue(messageForBob.getType() == CiphertextMessage.PREKEY_TYPE);
+ assertTrue(messageForAlice.getType() == CiphertextMessage.PREKEY_TYPE);
+
+ assertFalse(isSessionIdEqual(aliceStore, bobStore));
+
+ byte[] alicePlaintext = aliceSessionCipher.decrypt(new PreKeyWhisperMessage(messageForAlice.serialize()));
+ byte[] bobPlaintext = bobSessionCipher.decrypt(new PreKeyWhisperMessage(messageForBob.serialize()));
+
+ assertTrue(new String(alicePlaintext).equals("sample message"));
+ assertTrue(new String(bobPlaintext).equals("hey there"));
+
+ assertTrue(aliceStore.loadSession(BOB_RECIPENT_ID, 1).getSessionState().getSessionVersion() == 3);
+ assertTrue(bobStore.loadSession(ALICE_RECIPIENT_ID, 1).getSessionState().getSessionVersion() == 3);
+
+ assertFalse(isSessionIdEqual(aliceStore, bobStore));
+
+ CiphertextMessage aliceResponse = aliceSessionCipher.encrypt("second message".getBytes());
+
+ assertTrue(aliceResponse.getType() == CiphertextMessage.WHISPER_TYPE);
+
+ byte[] responsePlaintext = bobSessionCipher.decrypt(new WhisperMessage(aliceResponse.serialize()));
+
+ assertTrue(new String(responsePlaintext).equals("second message"));
+ assertTrue(isSessionIdEqual(aliceStore, bobStore));
+
+ CiphertextMessage finalMessage = bobSessionCipher.encrypt("third message".getBytes());
+
+ assertTrue(finalMessage.getType() == CiphertextMessage.WHISPER_TYPE);
+
+ byte[] finalPlaintext = aliceSessionCipher.decrypt(new WhisperMessage(finalMessage.serialize()));
+
+ assertTrue(new String(finalPlaintext).equals("third message"));
+ assertTrue(isSessionIdEqual(aliceStore, bobStore));
+ }
+
+ public void testLostSimultaneousInitiate() throws InvalidKeyException, UntrustedIdentityException, InvalidVersionException, InvalidMessageException, DuplicateMessageException, LegacyMessageException, InvalidKeyIdException, NoSessionException {
+ AxolotlStore aliceStore = new InMemoryAxolotlStore();
+ AxolotlStore bobStore = new InMemoryAxolotlStore();
+
+ PreKeyBundle alicePreKeyBundle = createAlicePreKeyBundle(aliceStore);
+ PreKeyBundle bobPreKeyBundle = createBobPreKeyBundle(bobStore);
+
+ SessionBuilder aliceSessionBuilder = new SessionBuilder(aliceStore, BOB_RECIPENT_ID, 1);
+ SessionBuilder bobSessionBuilder = new SessionBuilder(bobStore, ALICE_RECIPIENT_ID, 1);
+
+ SessionCipher aliceSessionCipher = new SessionCipher(aliceStore, BOB_RECIPENT_ID, 1);
+ SessionCipher bobSessionCipher = new SessionCipher(bobStore, ALICE_RECIPIENT_ID, 1);
+
+ aliceSessionBuilder.process(bobPreKeyBundle);
+ bobSessionBuilder.process(alicePreKeyBundle);
+
+ CiphertextMessage messageForBob = aliceSessionCipher.encrypt("hey there".getBytes());
+ CiphertextMessage messageForAlice = bobSessionCipher.encrypt("sample message".getBytes());
+
+ assertTrue(messageForBob.getType() == CiphertextMessage.PREKEY_TYPE);
+ assertTrue(messageForAlice.getType() == CiphertextMessage.PREKEY_TYPE);
+
+ assertFalse(isSessionIdEqual(aliceStore, bobStore));
+
+ byte[] bobPlaintext = bobSessionCipher.decrypt(new PreKeyWhisperMessage(messageForBob.serialize()));
+
+ assertTrue(new String(bobPlaintext).equals("hey there"));
+ assertTrue(bobStore.loadSession(ALICE_RECIPIENT_ID, 1).getSessionState().getSessionVersion() == 3);
+
+ CiphertextMessage aliceResponse = aliceSessionCipher.encrypt("second message".getBytes());
+
+ assertTrue(aliceResponse.getType() == CiphertextMessage.PREKEY_TYPE);
+
+ byte[] responsePlaintext = bobSessionCipher.decrypt(new PreKeyWhisperMessage(aliceResponse.serialize()));
+
+ assertTrue(new String(responsePlaintext).equals("second message"));
+ assertTrue(isSessionIdEqual(aliceStore, bobStore));
+
+ CiphertextMessage finalMessage = bobSessionCipher.encrypt("third message".getBytes());
+
+ assertTrue(finalMessage.getType() == CiphertextMessage.WHISPER_TYPE);
+
+ byte[] finalPlaintext = aliceSessionCipher.decrypt(new WhisperMessage(finalMessage.serialize()));
+
+ assertTrue(new String(finalPlaintext).equals("third message"));
+ assertTrue(isSessionIdEqual(aliceStore, bobStore));
+ }
+
+ public void testSimultaneousInitiateLostMessage()
+ throws InvalidKeyException, UntrustedIdentityException, InvalidVersionException,
+ InvalidMessageException, DuplicateMessageException, LegacyMessageException,
+ InvalidKeyIdException, NoSessionException
+ {
+ AxolotlStore aliceStore = new InMemoryAxolotlStore();
+ AxolotlStore bobStore = new InMemoryAxolotlStore();
+
+ PreKeyBundle alicePreKeyBundle = createAlicePreKeyBundle(aliceStore);
+ PreKeyBundle bobPreKeyBundle = createBobPreKeyBundle(bobStore);
+
+ SessionBuilder aliceSessionBuilder = new SessionBuilder(aliceStore, BOB_RECIPENT_ID, 1);
+ SessionBuilder bobSessionBuilder = new SessionBuilder(bobStore, ALICE_RECIPIENT_ID, 1);
+
+ SessionCipher aliceSessionCipher = new SessionCipher(aliceStore, BOB_RECIPENT_ID, 1);
+ SessionCipher bobSessionCipher = new SessionCipher(bobStore, ALICE_RECIPIENT_ID, 1);
+
+ aliceSessionBuilder.process(bobPreKeyBundle);
+ bobSessionBuilder.process(alicePreKeyBundle);
+
+ CiphertextMessage messageForBob = aliceSessionCipher.encrypt("hey there".getBytes());
+ CiphertextMessage messageForAlice = bobSessionCipher.encrypt("sample message".getBytes());
+
+ assertTrue(messageForBob.getType() == CiphertextMessage.PREKEY_TYPE);
+ assertTrue(messageForAlice.getType() == CiphertextMessage.PREKEY_TYPE);
+
+ assertFalse(isSessionIdEqual(aliceStore, bobStore));
+
+ byte[] alicePlaintext = aliceSessionCipher.decrypt(new PreKeyWhisperMessage(messageForAlice.serialize()));
+ byte[] bobPlaintext = bobSessionCipher.decrypt(new PreKeyWhisperMessage(messageForBob.serialize()));
+
+ assertTrue(new String(alicePlaintext).equals("sample message"));
+ assertTrue(new String(bobPlaintext).equals("hey there"));
+
+ assertTrue(aliceStore.loadSession(BOB_RECIPENT_ID, 1).getSessionState().getSessionVersion() == 3);
+ assertTrue(bobStore.loadSession(ALICE_RECIPIENT_ID, 1).getSessionState().getSessionVersion() == 3);
+
+ assertFalse(isSessionIdEqual(aliceStore, bobStore));
+
+ CiphertextMessage aliceResponse = aliceSessionCipher.encrypt("second message".getBytes());
+
+ assertTrue(aliceResponse.getType() == CiphertextMessage.WHISPER_TYPE);
+
+// byte[] responsePlaintext = bobSessionCipher.decrypt(new WhisperMessage(aliceResponse.serialize()));
+//
+// assertTrue(new String(responsePlaintext).equals("second message"));
+// assertTrue(isSessionIdEqual(aliceStore, bobStore));
+ assertFalse(isSessionIdEqual(aliceStore, bobStore));
+
+ CiphertextMessage finalMessage = bobSessionCipher.encrypt("third message".getBytes());
+
+ assertTrue(finalMessage.getType() == CiphertextMessage.WHISPER_TYPE);
+
+ byte[] finalPlaintext = aliceSessionCipher.decrypt(new WhisperMessage(finalMessage.serialize()));
+
+ assertTrue(new String(finalPlaintext).equals("third message"));
+ assertTrue(isSessionIdEqual(aliceStore, bobStore));
+ }
+
+ public void testSimultaneousInitiateRepeatedMessages()
+ throws InvalidKeyException, UntrustedIdentityException, InvalidVersionException,
+ InvalidMessageException, DuplicateMessageException, LegacyMessageException,
+ InvalidKeyIdException, NoSessionException
+ {
+ AxolotlStore aliceStore = new InMemoryAxolotlStore();
+ AxolotlStore bobStore = new InMemoryAxolotlStore();
+
+ PreKeyBundle alicePreKeyBundle = createAlicePreKeyBundle(aliceStore);
+ PreKeyBundle bobPreKeyBundle = createBobPreKeyBundle(bobStore);
+
+ SessionBuilder aliceSessionBuilder = new SessionBuilder(aliceStore, BOB_RECIPENT_ID, 1);
+ SessionBuilder bobSessionBuilder = new SessionBuilder(bobStore, ALICE_RECIPIENT_ID, 1);
+
+ SessionCipher aliceSessionCipher = new SessionCipher(aliceStore, BOB_RECIPENT_ID, 1);
+ SessionCipher bobSessionCipher = new SessionCipher(bobStore, ALICE_RECIPIENT_ID, 1);
+
+ aliceSessionBuilder.process(bobPreKeyBundle);
+ bobSessionBuilder.process(alicePreKeyBundle);
+
+ CiphertextMessage messageForBob = aliceSessionCipher.encrypt("hey there".getBytes());
+ CiphertextMessage messageForAlice = bobSessionCipher.encrypt("sample message".getBytes());
+
+ assertTrue(messageForBob.getType() == CiphertextMessage.PREKEY_TYPE);
+ assertTrue(messageForAlice.getType() == CiphertextMessage.PREKEY_TYPE);
+
+ assertFalse(isSessionIdEqual(aliceStore, bobStore));
+
+ byte[] alicePlaintext = aliceSessionCipher.decrypt(new PreKeyWhisperMessage(messageForAlice.serialize()));
+ byte[] bobPlaintext = bobSessionCipher.decrypt(new PreKeyWhisperMessage(messageForBob.serialize()));
+
+ assertTrue(new String(alicePlaintext).equals("sample message"));
+ assertTrue(new String(bobPlaintext).equals("hey there"));
+
+ assertTrue(aliceStore.loadSession(BOB_RECIPENT_ID, 1).getSessionState().getSessionVersion() == 3);
+ assertTrue(bobStore.loadSession(ALICE_RECIPIENT_ID, 1).getSessionState().getSessionVersion() == 3);
+
+ assertFalse(isSessionIdEqual(aliceStore, bobStore));
+
+ for (int i=0;i<50;i++) {
+ Log.w("SimultaneousInitiateTests", "Iteration: " + i);
+ CiphertextMessage messageForBobRepeat = aliceSessionCipher.encrypt("hey there".getBytes());
+ CiphertextMessage messageForAliceRepeat = bobSessionCipher.encrypt("sample message".getBytes());
+
+ assertTrue(messageForBobRepeat.getType() == CiphertextMessage.WHISPER_TYPE);
+ assertTrue(messageForAliceRepeat.getType() == CiphertextMessage.WHISPER_TYPE);
+
+ assertFalse(isSessionIdEqual(aliceStore, bobStore));
+
+ byte[] alicePlaintextRepeat = aliceSessionCipher.decrypt(new WhisperMessage(messageForAliceRepeat.serialize()));
+ byte[] bobPlaintextRepeat = bobSessionCipher.decrypt(new WhisperMessage(messageForBobRepeat.serialize()));
+
+ assertTrue(new String(alicePlaintextRepeat).equals("sample message"));
+ assertTrue(new String(bobPlaintextRepeat).equals("hey there"));
+
+ assertFalse(isSessionIdEqual(aliceStore, bobStore));
+ }
+
+ CiphertextMessage aliceResponse = aliceSessionCipher.encrypt("second message".getBytes());
+
+ assertTrue(aliceResponse.getType() == CiphertextMessage.WHISPER_TYPE);
+
+ byte[] responsePlaintext = bobSessionCipher.decrypt(new WhisperMessage(aliceResponse.serialize()));
+
+ assertTrue(new String(responsePlaintext).equals("second message"));
+ assertTrue(isSessionIdEqual(aliceStore, bobStore));
+
+ CiphertextMessage finalMessage = bobSessionCipher.encrypt("third message".getBytes());
+
+ assertTrue(finalMessage.getType() == CiphertextMessage.WHISPER_TYPE);
+
+ byte[] finalPlaintext = aliceSessionCipher.decrypt(new WhisperMessage(finalMessage.serialize()));
+
+ assertTrue(new String(finalPlaintext).equals("third message"));
+ assertTrue(isSessionIdEqual(aliceStore, bobStore));
+ }
+
+ public void testRepeatedSimultaneousInitiateRepeatedMessages()
+ throws InvalidKeyException, UntrustedIdentityException, InvalidVersionException,
+ InvalidMessageException, DuplicateMessageException, LegacyMessageException,
+ InvalidKeyIdException, NoSessionException
+ {
+ AxolotlStore aliceStore = new InMemoryAxolotlStore();
+ AxolotlStore bobStore = new InMemoryAxolotlStore();
+
+
+ SessionBuilder aliceSessionBuilder = new SessionBuilder(aliceStore, BOB_RECIPENT_ID, 1);
+ SessionBuilder bobSessionBuilder = new SessionBuilder(bobStore, ALICE_RECIPIENT_ID, 1);
+
+ SessionCipher aliceSessionCipher = new SessionCipher(aliceStore, BOB_RECIPENT_ID, 1);
+ SessionCipher bobSessionCipher = new SessionCipher(bobStore, ALICE_RECIPIENT_ID, 1);
+
+ for (int i=0;i<15;i++) {
+ PreKeyBundle alicePreKeyBundle = createAlicePreKeyBundle(aliceStore);
+ PreKeyBundle bobPreKeyBundle = createBobPreKeyBundle(bobStore);
+
+ aliceSessionBuilder.process(bobPreKeyBundle);
+ bobSessionBuilder.process(alicePreKeyBundle);
+
+ CiphertextMessage messageForBob = aliceSessionCipher.encrypt("hey there".getBytes());
+ CiphertextMessage messageForAlice = bobSessionCipher.encrypt("sample message".getBytes());
+
+ assertTrue(messageForBob.getType() == CiphertextMessage.PREKEY_TYPE);
+ assertTrue(messageForAlice.getType() == CiphertextMessage.PREKEY_TYPE);
+
+ assertFalse(isSessionIdEqual(aliceStore, bobStore));
+
+ byte[] alicePlaintext = aliceSessionCipher.decrypt(new PreKeyWhisperMessage(messageForAlice.serialize()));
+ byte[] bobPlaintext = bobSessionCipher.decrypt(new PreKeyWhisperMessage(messageForBob.serialize()));
+
+ assertTrue(new String(alicePlaintext).equals("sample message"));
+ assertTrue(new String(bobPlaintext).equals("hey there"));
+
+ assertTrue(aliceStore.loadSession(BOB_RECIPENT_ID, 1).getSessionState().getSessionVersion() == 3);
+ assertTrue(bobStore.loadSession(ALICE_RECIPIENT_ID, 1).getSessionState().getSessionVersion() == 3);
+
+ assertFalse(isSessionIdEqual(aliceStore, bobStore));
+ }
+
+ for (int i=0;i<50;i++) {
+ Log.w("SimultaneousInitiateTests", "Iteration: " + i);
+ CiphertextMessage messageForBobRepeat = aliceSessionCipher.encrypt("hey there".getBytes());
+ CiphertextMessage messageForAliceRepeat = bobSessionCipher.encrypt("sample message".getBytes());
+
+ assertTrue(messageForBobRepeat.getType() == CiphertextMessage.WHISPER_TYPE);
+ assertTrue(messageForAliceRepeat.getType() == CiphertextMessage.WHISPER_TYPE);
+
+ assertFalse(isSessionIdEqual(aliceStore, bobStore));
+
+ byte[] alicePlaintextRepeat = aliceSessionCipher.decrypt(new WhisperMessage(messageForAliceRepeat.serialize()));
+ byte[] bobPlaintextRepeat = bobSessionCipher.decrypt(new WhisperMessage(messageForBobRepeat.serialize()));
+
+ assertTrue(new String(alicePlaintextRepeat).equals("sample message"));
+ assertTrue(new String(bobPlaintextRepeat).equals("hey there"));
+
+ assertFalse(isSessionIdEqual(aliceStore, bobStore));
+ }
+
+ CiphertextMessage aliceResponse = aliceSessionCipher.encrypt("second message".getBytes());
+
+ assertTrue(aliceResponse.getType() == CiphertextMessage.WHISPER_TYPE);
+
+ byte[] responsePlaintext = bobSessionCipher.decrypt(new WhisperMessage(aliceResponse.serialize()));
+
+ assertTrue(new String(responsePlaintext).equals("second message"));
+ assertTrue(isSessionIdEqual(aliceStore, bobStore));
+
+ CiphertextMessage finalMessage = bobSessionCipher.encrypt("third message".getBytes());
+
+ assertTrue(finalMessage.getType() == CiphertextMessage.WHISPER_TYPE);
+
+ byte[] finalPlaintext = aliceSessionCipher.decrypt(new WhisperMessage(finalMessage.serialize()));
+
+ assertTrue(new String(finalPlaintext).equals("third message"));
+ assertTrue(isSessionIdEqual(aliceStore, bobStore));
+ }
+
+ public void testRepeatedSimultaneousInitiateLostMessageRepeatedMessages()
+ throws InvalidKeyException, UntrustedIdentityException, InvalidVersionException,
+ InvalidMessageException, DuplicateMessageException, LegacyMessageException,
+ InvalidKeyIdException, NoSessionException
+ {
+ AxolotlStore aliceStore = new InMemoryAxolotlStore();
+ AxolotlStore bobStore = new InMemoryAxolotlStore();
+
+
+ SessionBuilder aliceSessionBuilder = new SessionBuilder(aliceStore, BOB_RECIPENT_ID, 1);
+ SessionBuilder bobSessionBuilder = new SessionBuilder(bobStore, ALICE_RECIPIENT_ID, 1);
+
+ SessionCipher aliceSessionCipher = new SessionCipher(aliceStore, BOB_RECIPENT_ID, 1);
+ SessionCipher bobSessionCipher = new SessionCipher(bobStore, ALICE_RECIPIENT_ID, 1);
+
+// PreKeyBundle aliceLostPreKeyBundle = createAlicePreKeyBundle(aliceStore);
+ PreKeyBundle bobLostPreKeyBundle = createBobPreKeyBundle(bobStore);
+
+ aliceSessionBuilder.process(bobLostPreKeyBundle);
+// bobSessionBuilder.process(aliceLostPreKeyBundle);
+
+ CiphertextMessage lostMessageForBob = aliceSessionCipher.encrypt("hey there".getBytes());
+// CiphertextMessage lostMessageForAlice = bobSessionCipher.encrypt("sample message".getBytes());
+
+ for (int i=0;i<15;i++) {
+ PreKeyBundle alicePreKeyBundle = createAlicePreKeyBundle(aliceStore);
+ PreKeyBundle bobPreKeyBundle = createBobPreKeyBundle(bobStore);
+
+ aliceSessionBuilder.process(bobPreKeyBundle);
+ bobSessionBuilder.process(alicePreKeyBundle);
+
+ CiphertextMessage messageForBob = aliceSessionCipher.encrypt("hey there".getBytes());
+ CiphertextMessage messageForAlice = bobSessionCipher.encrypt("sample message".getBytes());
+
+ assertTrue(messageForBob.getType() == CiphertextMessage.PREKEY_TYPE);
+ assertTrue(messageForAlice.getType() == CiphertextMessage.PREKEY_TYPE);
+
+ assertFalse(isSessionIdEqual(aliceStore, bobStore));
+
+ byte[] alicePlaintext = aliceSessionCipher.decrypt(new PreKeyWhisperMessage(messageForAlice.serialize()));
+ byte[] bobPlaintext = bobSessionCipher.decrypt(new PreKeyWhisperMessage(messageForBob.serialize()));
+
+ assertTrue(new String(alicePlaintext).equals("sample message"));
+ assertTrue(new String(bobPlaintext).equals("hey there"));
+
+ assertTrue(aliceStore.loadSession(BOB_RECIPENT_ID, 1).getSessionState().getSessionVersion() == 3);
+ assertTrue(bobStore.loadSession(ALICE_RECIPIENT_ID, 1).getSessionState().getSessionVersion() == 3);
+
+ assertFalse(isSessionIdEqual(aliceStore, bobStore));
+ }
+
+ for (int i=0;i<50;i++) {
+ Log.w("SimultaneousInitiateTests", "Iteration: " + i);
+ CiphertextMessage messageForBobRepeat = aliceSessionCipher.encrypt("hey there".getBytes());
+ CiphertextMessage messageForAliceRepeat = bobSessionCipher.encrypt("sample message".getBytes());
+
+ assertTrue(messageForBobRepeat.getType() == CiphertextMessage.WHISPER_TYPE);
+ assertTrue(messageForAliceRepeat.getType() == CiphertextMessage.WHISPER_TYPE);
+
+ assertFalse(isSessionIdEqual(aliceStore, bobStore));
+
+ byte[] alicePlaintextRepeat = aliceSessionCipher.decrypt(new WhisperMessage(messageForAliceRepeat.serialize()));
+ byte[] bobPlaintextRepeat = bobSessionCipher.decrypt(new WhisperMessage(messageForBobRepeat.serialize()));
+
+ assertTrue(new String(alicePlaintextRepeat).equals("sample message"));
+ assertTrue(new String(bobPlaintextRepeat).equals("hey there"));
+
+ assertFalse(isSessionIdEqual(aliceStore, bobStore));
+ }
+
+ CiphertextMessage aliceResponse = aliceSessionCipher.encrypt("second message".getBytes());
+
+ assertTrue(aliceResponse.getType() == CiphertextMessage.WHISPER_TYPE);
+
+ byte[] responsePlaintext = bobSessionCipher.decrypt(new WhisperMessage(aliceResponse.serialize()));
+
+ assertTrue(new String(responsePlaintext).equals("second message"));
+ assertTrue(isSessionIdEqual(aliceStore, bobStore));
+
+ CiphertextMessage finalMessage = bobSessionCipher.encrypt("third message".getBytes());
+
+ assertTrue(finalMessage.getType() == CiphertextMessage.WHISPER_TYPE);
+
+ byte[] finalPlaintext = aliceSessionCipher.decrypt(new WhisperMessage(finalMessage.serialize()));
+
+ assertTrue(new String(finalPlaintext).equals("third message"));
+ assertTrue(isSessionIdEqual(aliceStore, bobStore));
+
+ byte[] lostMessagePlaintext = bobSessionCipher.decrypt(new PreKeyWhisperMessage(lostMessageForBob.serialize()));
+ assertTrue(new String(lostMessagePlaintext).equals("hey there"));
+
+ assertFalse(isSessionIdEqual(aliceStore, bobStore));
+
+ CiphertextMessage blastFromThePast = bobSessionCipher.encrypt("unexpected!".getBytes());
+ byte[] blastFromThePastPlaintext = aliceSessionCipher.decrypt(new WhisperMessage(blastFromThePast.serialize()));
+
+ assertTrue(new String(blastFromThePastPlaintext).equals("unexpected!"));
+ assertTrue(isSessionIdEqual(aliceStore, bobStore));
+ }
+
+ private boolean isSessionIdEqual(AxolotlStore aliceStore, AxolotlStore bobStore) {
+ return Arrays.equals(aliceStore.loadSession(BOB_RECIPENT_ID, 1).getSessionState().getAliceBaseKey(),
+ bobStore.loadSession(ALICE_RECIPIENT_ID, 1).getSessionState().getAliceBaseKey());
+ }
+
+ private PreKeyBundle createAlicePreKeyBundle(AxolotlStore aliceStore) throws InvalidKeyException {
+ ECKeyPair aliceUnsignedPreKey = Curve.generateKeyPair();
+ int aliceUnsignedPreKeyId = new Random().nextInt(Medium.MAX_VALUE);
+ byte[] aliceSignature = Curve.calculateSignature(aliceStore.getIdentityKeyPair().getPrivateKey(),
+ aliceSignedPreKey.getPublicKey().serialize());
+
+ PreKeyBundle alicePreKeyBundle = new PreKeyBundle(1, 1,
+ aliceUnsignedPreKeyId, aliceUnsignedPreKey.getPublicKey(),
+ aliceSignedPreKeyId, aliceSignedPreKey.getPublicKey(),
+ aliceSignature, aliceStore.getIdentityKeyPair().getPublicKey());
+
+ aliceStore.storeSignedPreKey(aliceSignedPreKeyId, new SignedPreKeyRecord(aliceSignedPreKeyId, System.currentTimeMillis(), aliceSignedPreKey, aliceSignature));
+ aliceStore.storePreKey(aliceUnsignedPreKeyId, new PreKeyRecord(aliceUnsignedPreKeyId, aliceUnsignedPreKey));
+
+ return alicePreKeyBundle;
+ }
+
+ private PreKeyBundle createBobPreKeyBundle(AxolotlStore bobStore) throws InvalidKeyException {
+ ECKeyPair bobUnsignedPreKey = Curve.generateKeyPair();
+ int bobUnsignedPreKeyId = new Random().nextInt(Medium.MAX_VALUE);
+ byte[] bobSignature = Curve.calculateSignature(bobStore.getIdentityKeyPair().getPrivateKey(),
+ bobSignedPreKey.getPublicKey().serialize());
+
+ PreKeyBundle bobPreKeyBundle = new PreKeyBundle(1, 1,
+ bobUnsignedPreKeyId, bobUnsignedPreKey.getPublicKey(),
+ bobSignedPreKeyId, bobSignedPreKey.getPublicKey(),
+ bobSignature, bobStore.getIdentityKeyPair().getPublicKey());
+
+ bobStore.storeSignedPreKey(bobSignedPreKeyId, new SignedPreKeyRecord(bobSignedPreKeyId, System.currentTimeMillis(), bobSignedPreKey, bobSignature));
+ bobStore.storePreKey(bobUnsignedPreKeyId, new PreKeyRecord(bobUnsignedPreKeyId, bobUnsignedPreKey));
+
+ return bobPreKeyBundle;
+ }
+}
diff --git a/src/androidTest/java/org/whispersystems/test/ecc/Curve25519Test.java b/src/androidTest/java/org/whispersystems/test/ecc/Curve25519Test.java
new file mode 100644
index 00000000..4b8ce2ea
--- /dev/null
+++ b/src/androidTest/java/org/whispersystems/test/ecc/Curve25519Test.java
@@ -0,0 +1,154 @@
+package org.whispersystems.test.ecc;
+
+import android.test.AndroidTestCase;
+
+import org.whispersystems.libaxolotl.InvalidKeyException;
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.ecc.ECPrivateKey;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+
+import java.util.Arrays;
+
+
+public class Curve25519Test extends AndroidTestCase {
+
+ public void testAgreement() throws InvalidKeyException {
+
+ byte[] alicePublic = {(byte) 0x05, (byte) 0x1b, (byte) 0xb7, (byte) 0x59, (byte) 0x66,
+ (byte) 0xf2, (byte) 0xe9, (byte) 0x3a, (byte) 0x36, (byte) 0x91,
+ (byte) 0xdf, (byte) 0xff, (byte) 0x94, (byte) 0x2b, (byte) 0xb2,
+ (byte) 0xa4, (byte) 0x66, (byte) 0xa1, (byte) 0xc0, (byte) 0x8b,
+ (byte) 0x8d, (byte) 0x78, (byte) 0xca, (byte) 0x3f, (byte) 0x4d,
+ (byte) 0x6d, (byte) 0xf8, (byte) 0xb8, (byte) 0xbf, (byte) 0xa2,
+ (byte) 0xe4, (byte) 0xee, (byte) 0x28};
+
+ byte[] alicePrivate = {(byte) 0xc8, (byte) 0x06, (byte) 0x43, (byte) 0x9d, (byte) 0xc9,
+ (byte) 0xd2, (byte) 0xc4, (byte) 0x76, (byte) 0xff, (byte) 0xed,
+ (byte) 0x8f, (byte) 0x25, (byte) 0x80, (byte) 0xc0, (byte) 0x88,
+ (byte) 0x8d, (byte) 0x58, (byte) 0xab, (byte) 0x40, (byte) 0x6b,
+ (byte) 0xf7, (byte) 0xae, (byte) 0x36, (byte) 0x98, (byte) 0x87,
+ (byte) 0x90, (byte) 0x21, (byte) 0xb9, (byte) 0x6b, (byte) 0xb4,
+ (byte) 0xbf, (byte) 0x59};
+
+ byte[] bobPublic = {(byte) 0x05, (byte) 0x65, (byte) 0x36, (byte) 0x14, (byte) 0x99,
+ (byte) 0x3d, (byte) 0x2b, (byte) 0x15, (byte) 0xee, (byte) 0x9e,
+ (byte) 0x5f, (byte) 0xd3, (byte) 0xd8, (byte) 0x6c, (byte) 0xe7,
+ (byte) 0x19, (byte) 0xef, (byte) 0x4e, (byte) 0xc1, (byte) 0xda,
+ (byte) 0xae, (byte) 0x18, (byte) 0x86, (byte) 0xa8, (byte) 0x7b,
+ (byte) 0x3f, (byte) 0x5f, (byte) 0xa9, (byte) 0x56, (byte) 0x5a,
+ (byte) 0x27, (byte) 0xa2, (byte) 0x2f};
+
+ byte[] bobPrivate = {(byte) 0xb0, (byte) 0x3b, (byte) 0x34, (byte) 0xc3, (byte) 0x3a,
+ (byte) 0x1c, (byte) 0x44, (byte) 0xf2, (byte) 0x25, (byte) 0xb6,
+ (byte) 0x62, (byte) 0xd2, (byte) 0xbf, (byte) 0x48, (byte) 0x59,
+ (byte) 0xb8, (byte) 0x13, (byte) 0x54, (byte) 0x11, (byte) 0xfa,
+ (byte) 0x7b, (byte) 0x03, (byte) 0x86, (byte) 0xd4, (byte) 0x5f,
+ (byte) 0xb7, (byte) 0x5d, (byte) 0xc5, (byte) 0xb9, (byte) 0x1b,
+ (byte) 0x44, (byte) 0x66};
+
+ byte[] shared = {(byte) 0x32, (byte) 0x5f, (byte) 0x23, (byte) 0x93, (byte) 0x28,
+ (byte) 0x94, (byte) 0x1c, (byte) 0xed, (byte) 0x6e, (byte) 0x67,
+ (byte) 0x3b, (byte) 0x86, (byte) 0xba, (byte) 0x41, (byte) 0x01,
+ (byte) 0x74, (byte) 0x48, (byte) 0xe9, (byte) 0x9b, (byte) 0x64,
+ (byte) 0x9a, (byte) 0x9c, (byte) 0x38, (byte) 0x06, (byte) 0xc1,
+ (byte) 0xdd, (byte) 0x7c, (byte) 0xa4, (byte) 0xc4, (byte) 0x77,
+ (byte) 0xe6, (byte) 0x29};
+
+ ECPublicKey alicePublicKey = Curve.decodePoint(alicePublic, 0);
+ ECPrivateKey alicePrivateKey = Curve.decodePrivatePoint(alicePrivate);
+
+ ECPublicKey bobPublicKey = Curve.decodePoint(bobPublic, 0);
+ ECPrivateKey bobPrivateKey = Curve.decodePrivatePoint(bobPrivate);
+
+ byte[] sharedOne = Curve.calculateAgreement(alicePublicKey, bobPrivateKey);
+ byte[] sharedTwo = Curve.calculateAgreement(bobPublicKey, alicePrivateKey);
+
+ assertTrue(Arrays.equals(sharedOne, shared));
+ assertTrue(Arrays.equals(sharedTwo, shared));
+ }
+
+ public void testRandomAgreements() throws InvalidKeyException {
+ for (int i=0;i<50;i++) {
+ ECKeyPair alice = Curve.generateKeyPair();
+ ECKeyPair bob = Curve.generateKeyPair();
+
+ byte[] sharedAlice = Curve.calculateAgreement(bob.getPublicKey(), alice.getPrivateKey());
+ byte[] sharedBob = Curve.calculateAgreement(alice.getPublicKey(), bob.getPrivateKey());
+
+ assertTrue(Arrays.equals(sharedAlice, sharedBob));
+ }
+ }
+
+ public void testSignature() throws InvalidKeyException {
+ byte[] aliceIdentityPrivate = {(byte)0xc0, (byte)0x97, (byte)0x24, (byte)0x84, (byte)0x12,
+ (byte)0xe5, (byte)0x8b, (byte)0xf0, (byte)0x5d, (byte)0xf4,
+ (byte)0x87, (byte)0x96, (byte)0x82, (byte)0x05, (byte)0x13,
+ (byte)0x27, (byte)0x94, (byte)0x17, (byte)0x8e, (byte)0x36,
+ (byte)0x76, (byte)0x37, (byte)0xf5, (byte)0x81, (byte)0x8f,
+ (byte)0x81, (byte)0xe0, (byte)0xe6, (byte)0xce, (byte)0x73,
+ (byte)0xe8, (byte)0x65};
+
+ byte[] aliceIdentityPublic = {(byte)0x05, (byte)0xab, (byte)0x7e, (byte)0x71, (byte)0x7d,
+ (byte)0x4a, (byte)0x16, (byte)0x3b, (byte)0x7d, (byte)0x9a,
+ (byte)0x1d, (byte)0x80, (byte)0x71, (byte)0xdf, (byte)0xe9,
+ (byte)0xdc, (byte)0xf8, (byte)0xcd, (byte)0xcd, (byte)0x1c,
+ (byte)0xea, (byte)0x33, (byte)0x39, (byte)0xb6, (byte)0x35,
+ (byte)0x6b, (byte)0xe8, (byte)0x4d, (byte)0x88, (byte)0x7e,
+ (byte)0x32, (byte)0x2c, (byte)0x64};
+
+ byte[] aliceEphemeralPublic = {(byte)0x05, (byte)0xed, (byte)0xce, (byte)0x9d, (byte)0x9c,
+ (byte)0x41, (byte)0x5c, (byte)0xa7, (byte)0x8c, (byte)0xb7,
+ (byte)0x25, (byte)0x2e, (byte)0x72, (byte)0xc2, (byte)0xc4,
+ (byte)0xa5, (byte)0x54, (byte)0xd3, (byte)0xeb, (byte)0x29,
+ (byte)0x48, (byte)0x5a, (byte)0x0e, (byte)0x1d, (byte)0x50,
+ (byte)0x31, (byte)0x18, (byte)0xd1, (byte)0xa8, (byte)0x2d,
+ (byte)0x99, (byte)0xfb, (byte)0x4a};
+
+ byte[] aliceSignature = {(byte)0x5d, (byte)0xe8, (byte)0x8c, (byte)0xa9, (byte)0xa8,
+ (byte)0x9b, (byte)0x4a, (byte)0x11, (byte)0x5d, (byte)0xa7,
+ (byte)0x91, (byte)0x09, (byte)0xc6, (byte)0x7c, (byte)0x9c,
+ (byte)0x74, (byte)0x64, (byte)0xa3, (byte)0xe4, (byte)0x18,
+ (byte)0x02, (byte)0x74, (byte)0xf1, (byte)0xcb, (byte)0x8c,
+ (byte)0x63, (byte)0xc2, (byte)0x98, (byte)0x4e, (byte)0x28,
+ (byte)0x6d, (byte)0xfb, (byte)0xed, (byte)0xe8, (byte)0x2d,
+ (byte)0xeb, (byte)0x9d, (byte)0xcd, (byte)0x9f, (byte)0xae,
+ (byte)0x0b, (byte)0xfb, (byte)0xb8, (byte)0x21, (byte)0x56,
+ (byte)0x9b, (byte)0x3d, (byte)0x90, (byte)0x01, (byte)0xbd,
+ (byte)0x81, (byte)0x30, (byte)0xcd, (byte)0x11, (byte)0xd4,
+ (byte)0x86, (byte)0xce, (byte)0xf0, (byte)0x47, (byte)0xbd,
+ (byte)0x60, (byte)0xb8, (byte)0x6e, (byte)0x88};
+
+ ECPrivateKey alicePrivateKey = Curve.decodePrivatePoint(aliceIdentityPrivate);
+ ECPublicKey alicePublicKey = Curve.decodePoint(aliceIdentityPublic, 0);
+ ECPublicKey aliceEphemeral = Curve.decodePoint(aliceEphemeralPublic, 0);
+
+ if (!Curve.verifySignature(alicePublicKey, aliceEphemeral.serialize(), aliceSignature)) {
+ throw new AssertionError("Sig verification failed!");
+ }
+
+ for (int i=0;i<aliceSignature.length;i++) {
+ byte[] modifiedSignature = new byte[aliceSignature.length];
+ System.arraycopy(aliceSignature, 0, modifiedSignature, 0, modifiedSignature.length);
+
+ modifiedSignature[i] ^= 0x01;
+
+ if (Curve.verifySignature(alicePublicKey, aliceEphemeral.serialize(), modifiedSignature)) {
+ throw new AssertionError("Sig verification succeeded!");
+ }
+ }
+ }
+
+ public void testSignatureOverflow() throws InvalidKeyException {
+ ECKeyPair keys = Curve.generateKeyPair();
+ byte[] message = new byte[4096];
+
+ try {
+ byte[] signature = Curve.calculateSignature(keys.getPrivateKey(), message);
+ throw new InvalidKeyException("Should have asserted!");
+ } catch (AssertionError e) {
+ // Success!
+ }
+ }
+
+}
diff --git a/src/androidTest/java/org/whispersystems/test/groups/GroupCipherTest.java b/src/androidTest/java/org/whispersystems/test/groups/GroupCipherTest.java
new file mode 100644
index 00000000..6d93e921
--- /dev/null
+++ b/src/androidTest/java/org/whispersystems/test/groups/GroupCipherTest.java
@@ -0,0 +1,151 @@
+package org.whispersystems.test.groups;
+
+import android.test.AndroidTestCase;
+import android.util.Log;
+
+import org.whispersystems.libaxolotl.DuplicateMessageException;
+import org.whispersystems.libaxolotl.InvalidMessageException;
+import org.whispersystems.libaxolotl.LegacyMessageException;
+import org.whispersystems.libaxolotl.NoSessionException;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.groups.GroupCipher;
+import org.whispersystems.libaxolotl.groups.GroupSessionBuilder;
+import org.whispersystems.libaxolotl.protocol.SenderKeyDistributionMessage;
+import org.whispersystems.libaxolotl.util.KeyHelper;
+
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+public class GroupCipherTest extends AndroidTestCase {
+
+ public void testBasicEncryptDecrypt()
+ throws LegacyMessageException, DuplicateMessageException, InvalidMessageException, NoSessionException
+ {
+ InMemorySenderKeyStore aliceStore = new InMemorySenderKeyStore();
+ InMemorySenderKeyStore bobStore = new InMemorySenderKeyStore();
+
+ GroupSessionBuilder aliceSessionBuilder = new GroupSessionBuilder(aliceStore);
+ GroupSessionBuilder bobSessionBuilder = new GroupSessionBuilder(bobStore);
+
+ GroupCipher aliceGroupCipher = new GroupCipher(aliceStore, "groupWithBobInIt");
+ GroupCipher bobGroupCipher = new GroupCipher(bobStore, "groupWithBobInIt::aliceUserName");
+
+ byte[] aliceSenderKey = KeyHelper.generateSenderKey();
+ ECKeyPair aliceSenderSigningKey = KeyHelper.generateSenderSigningKey();
+ int aliceSenderKeyId = KeyHelper.generateSenderKeyId();
+
+ SenderKeyDistributionMessage aliceDistributionMessage =
+ aliceSessionBuilder.process("groupWithBobInIt", aliceSenderKeyId, 0,
+ aliceSenderKey, aliceSenderSigningKey);
+
+ bobSessionBuilder.process("groupWithBobInIt::aliceUserName", aliceDistributionMessage);
+
+ byte[] ciphertextFromAlice = aliceGroupCipher.encrypt("smert ze smert".getBytes());
+ byte[] plaintextFromAlice = bobGroupCipher.decrypt(ciphertextFromAlice);
+
+ assertTrue(new String(plaintextFromAlice).equals("smert ze smert"));
+ }
+
+ public void testBasicRatchet()
+ throws LegacyMessageException, DuplicateMessageException, InvalidMessageException, NoSessionException
+ {
+ InMemorySenderKeyStore aliceStore = new InMemorySenderKeyStore();
+ InMemorySenderKeyStore bobStore = new InMemorySenderKeyStore();
+
+ GroupSessionBuilder aliceSessionBuilder = new GroupSessionBuilder(aliceStore);
+ GroupSessionBuilder bobSessionBuilder = new GroupSessionBuilder(bobStore);
+
+ GroupCipher aliceGroupCipher = new GroupCipher(aliceStore, "groupWithBobInIt");
+ GroupCipher bobGroupCipher = new GroupCipher(bobStore, "groupWithBobInIt::aliceUserName");
+
+ byte[] aliceSenderKey = KeyHelper.generateSenderKey();
+ ECKeyPair aliceSenderSigningKey = KeyHelper.generateSenderSigningKey();
+ int aliceSenderKeyId = KeyHelper.generateSenderKeyId();
+
+ SenderKeyDistributionMessage aliceDistributionMessage =
+ aliceSessionBuilder.process("groupWithBobInIt", aliceSenderKeyId, 0,
+ aliceSenderKey, aliceSenderSigningKey);
+
+ bobSessionBuilder.process("groupWithBobInIt::aliceUserName", aliceDistributionMessage);
+
+ byte[] ciphertextFromAlice = aliceGroupCipher.encrypt("smert ze smert".getBytes());
+ byte[] ciphertextFromAlice2 = aliceGroupCipher.encrypt("smert ze smert2".getBytes());
+ byte[] ciphertextFromAlice3 = aliceGroupCipher.encrypt("smert ze smert3".getBytes());
+
+ byte[] plaintextFromAlice = bobGroupCipher.decrypt(ciphertextFromAlice);
+
+ try {
+ bobGroupCipher.decrypt(ciphertextFromAlice);
+ throw new AssertionError("Should have ratcheted forward!");
+ } catch (DuplicateMessageException dme) {
+ // good
+ }
+
+ byte[] plaintextFromAlice2 = bobGroupCipher.decrypt(ciphertextFromAlice2);
+ byte[] plaintextFromAlice3 = bobGroupCipher.decrypt(ciphertextFromAlice3);
+
+ assertTrue(new String(plaintextFromAlice).equals("smert ze smert"));
+ assertTrue(new String(plaintextFromAlice2).equals("smert ze smert2"));
+ assertTrue(new String(plaintextFromAlice3).equals("smert ze smert3"));
+ }
+
+ public void testOutOfOrder()
+ throws LegacyMessageException, DuplicateMessageException, InvalidMessageException, NoSessionException
+ {
+ InMemorySenderKeyStore aliceStore = new InMemorySenderKeyStore();
+ InMemorySenderKeyStore bobStore = new InMemorySenderKeyStore();
+
+ GroupSessionBuilder aliceSessionBuilder = new GroupSessionBuilder(aliceStore);
+ GroupSessionBuilder bobSessionBuilder = new GroupSessionBuilder(bobStore);
+
+ GroupCipher aliceGroupCipher = new GroupCipher(aliceStore, "groupWithBobInIt");
+ GroupCipher bobGroupCipher = new GroupCipher(bobStore, "groupWithBobInIt::aliceUserName");
+
+ byte[] aliceSenderKey = KeyHelper.generateSenderKey();
+ ECKeyPair aliceSenderSigningKey = KeyHelper.generateSenderSigningKey();
+ int aliceSenderKeyId = KeyHelper.generateSenderKeyId();
+
+ SenderKeyDistributionMessage aliceDistributionMessage =
+ aliceSessionBuilder.process("groupWithBobInIt", aliceSenderKeyId, 0,
+ aliceSenderKey, aliceSenderSigningKey);
+
+ bobSessionBuilder.process("groupWithBobInIt::aliceUserName", aliceDistributionMessage);
+
+
+ ArrayList<byte[]> ciphertexts = new ArrayList<>(100);
+
+ for (int i=0;i<100;i++) {
+ ciphertexts.add(aliceGroupCipher.encrypt("up the punks".getBytes()));
+ }
+
+ while (ciphertexts.size() > 0) {
+ int index = randomInt() % ciphertexts.size();
+ byte[] ciphertext = ciphertexts.remove(index);
+ byte[] plaintext = bobGroupCipher.decrypt(ciphertext);
+
+ assertTrue(new String(plaintext).equals("up the punks"));
+ }
+ }
+
+ public void testEncryptNoSession() {
+ InMemorySenderKeyStore aliceStore = new InMemorySenderKeyStore();
+ GroupCipher aliceGroupCipher = new GroupCipher(aliceStore, "groupWithBobInIt");
+ try {
+ aliceGroupCipher.encrypt("up the punks".getBytes());
+ throw new AssertionError("Should have failed!");
+ } catch (NoSessionException nse) {
+ // good
+ }
+ }
+
+ private int randomInt() {
+ try {
+ return SecureRandom.getInstance("SHA1PRNG").nextInt(Integer.MAX_VALUE);
+ } catch (NoSuchAlgorithmException e) {
+ throw new AssertionError(e);
+ }
+ }
+}
diff --git a/src/androidTest/java/org/whispersystems/test/groups/InMemorySenderKeyStore.java b/src/androidTest/java/org/whispersystems/test/groups/InMemorySenderKeyStore.java
new file mode 100644
index 00000000..450d802d
--- /dev/null
+++ b/src/androidTest/java/org/whispersystems/test/groups/InMemorySenderKeyStore.java
@@ -0,0 +1,33 @@
+package org.whispersystems.test.groups;
+
+import org.whispersystems.libaxolotl.groups.state.SenderKeyRecord;
+import org.whispersystems.libaxolotl.groups.state.SenderKeyStore;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+public class InMemorySenderKeyStore implements SenderKeyStore {
+
+ private final Map<String, SenderKeyRecord> store = new HashMap<>();
+
+ @Override
+ public void storeSenderKey(String senderKeyId, SenderKeyRecord record) {
+ store.put(senderKeyId, record);
+ }
+
+ @Override
+ public SenderKeyRecord loadSenderKey(String senderKeyId) {
+ try {
+ SenderKeyRecord record = store.get(senderKeyId);
+
+ if (record == null) {
+ return new SenderKeyRecord();
+ } else {
+ return new SenderKeyRecord(record.serialize());
+ }
+ } catch (IOException e) {
+ throw new AssertionError(e);
+ }
+ }
+}
diff --git a/src/androidTest/java/org/whispersystems/test/kdf/HKDFTest.java b/src/androidTest/java/org/whispersystems/test/kdf/HKDFTest.java
new file mode 100644
index 00000000..079bc4fa
--- /dev/null
+++ b/src/androidTest/java/org/whispersystems/test/kdf/HKDFTest.java
@@ -0,0 +1,139 @@
+package org.whispersystems.test.kdf;
+
+import android.test.AndroidTestCase;
+
+import org.whispersystems.libaxolotl.kdf.HKDF;
+
+import java.util.Arrays;
+
+public class HKDFTest extends AndroidTestCase {
+
+ public void testVectorV3() {
+ byte[] ikm = {0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b};
+
+ byte[] salt = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+ 0x0a, 0x0b, 0x0c};
+
+ byte[] info = {(byte) 0xf0, (byte) 0xf1, (byte) 0xf2, (byte) 0xf3, (byte) 0xf4,
+ (byte) 0xf5, (byte) 0xf6, (byte) 0xf7, (byte) 0xf8, (byte) 0xf9};
+
+ byte[] okm = {(byte) 0x3c, (byte) 0xb2, (byte) 0x5f, (byte) 0x25, (byte) 0xfa,
+ (byte) 0xac, (byte) 0xd5, (byte) 0x7a, (byte) 0x90, (byte) 0x43,
+ (byte) 0x4f, (byte) 0x64, (byte) 0xd0, (byte) 0x36, (byte) 0x2f,
+ (byte) 0x2a, (byte) 0x2d, (byte) 0x2d, (byte) 0x0a, (byte) 0x90,
+ (byte) 0xcf, (byte) 0x1a, (byte) 0x5a, (byte) 0x4c, (byte) 0x5d,
+ (byte) 0xb0, (byte) 0x2d, (byte) 0x56, (byte) 0xec, (byte) 0xc4,
+ (byte) 0xc5, (byte) 0xbf, (byte) 0x34, (byte) 0x00, (byte) 0x72,
+ (byte) 0x08, (byte) 0xd5, (byte) 0xb8, (byte) 0x87, (byte) 0x18,
+ (byte) 0x58, (byte) 0x65};
+
+ byte[] actualOutput = HKDF.createFor(3).deriveSecrets(ikm, salt, info, 42);
+
+ assertTrue(Arrays.equals(okm, actualOutput));
+ }
+
+ public void testVectorLongV3() {
+ byte[] ikm = {(byte) 0x00, (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04,
+ (byte) 0x05, (byte) 0x06, (byte) 0x07, (byte) 0x08, (byte) 0x09,
+ (byte) 0x0a, (byte) 0x0b, (byte) 0x0c, (byte) 0x0d, (byte) 0x0e,
+ (byte) 0x0f, (byte) 0x10, (byte) 0x11, (byte) 0x12, (byte) 0x13,
+ (byte) 0x14, (byte) 0x15, (byte) 0x16, (byte) 0x17, (byte) 0x18,
+ (byte) 0x19, (byte) 0x1a, (byte) 0x1b, (byte) 0x1c, (byte) 0x1d,
+ (byte) 0x1e, (byte) 0x1f, (byte) 0x20, (byte) 0x21, (byte) 0x22,
+ (byte) 0x23, (byte) 0x24, (byte) 0x25, (byte) 0x26, (byte) 0x27,
+ (byte) 0x28, (byte) 0x29, (byte) 0x2a, (byte) 0x2b, (byte) 0x2c,
+ (byte) 0x2d, (byte) 0x2e, (byte) 0x2f, (byte) 0x30, (byte) 0x31,
+ (byte) 0x32, (byte) 0x33, (byte) 0x34, (byte) 0x35, (byte) 0x36,
+ (byte) 0x37, (byte) 0x38, (byte) 0x39, (byte) 0x3a, (byte) 0x3b,
+ (byte) 0x3c, (byte) 0x3d, (byte) 0x3e, (byte) 0x3f, (byte) 0x40,
+ (byte) 0x41, (byte) 0x42, (byte) 0x43, (byte) 0x44, (byte) 0x45,
+ (byte) 0x46, (byte) 0x47, (byte) 0x48, (byte) 0x49, (byte) 0x4a,
+ (byte) 0x4b, (byte) 0x4c, (byte) 0x4d, (byte) 0x4e, (byte) 0x4f};
+
+ byte[] salt = {(byte) 0x60, (byte) 0x61, (byte) 0x62, (byte) 0x63, (byte) 0x64,
+ (byte) 0x65, (byte) 0x66, (byte) 0x67, (byte) 0x68, (byte) 0x69,
+ (byte) 0x6a, (byte) 0x6b, (byte) 0x6c, (byte) 0x6d, (byte) 0x6e,
+ (byte) 0x6f, (byte) 0x70, (byte) 0x71, (byte) 0x72, (byte) 0x73,
+ (byte) 0x74, (byte) 0x75, (byte) 0x76, (byte) 0x77, (byte) 0x78,
+ (byte) 0x79, (byte) 0x7a, (byte) 0x7b, (byte) 0x7c, (byte) 0x7d,
+ (byte) 0x7e, (byte) 0x7f, (byte) 0x80, (byte) 0x81, (byte) 0x82,
+ (byte) 0x83, (byte) 0x84, (byte) 0x85, (byte) 0x86, (byte) 0x87,
+ (byte) 0x88, (byte) 0x89, (byte) 0x8a, (byte) 0x8b, (byte) 0x8c,
+ (byte) 0x8d, (byte) 0x8e, (byte) 0x8f, (byte) 0x90, (byte) 0x91,
+ (byte) 0x92, (byte) 0x93, (byte) 0x94, (byte) 0x95, (byte) 0x96,
+ (byte) 0x97, (byte) 0x98, (byte) 0x99, (byte) 0x9a, (byte) 0x9b,
+ (byte) 0x9c, (byte) 0x9d, (byte) 0x9e, (byte) 0x9f, (byte) 0xa0,
+ (byte) 0xa1, (byte) 0xa2, (byte) 0xa3, (byte) 0xa4, (byte) 0xa5,
+ (byte) 0xa6, (byte) 0xa7, (byte) 0xa8, (byte) 0xa9, (byte) 0xaa,
+ (byte) 0xab, (byte) 0xac, (byte) 0xad, (byte) 0xae, (byte) 0xaf};
+
+ byte[] info = {(byte) 0xb0, (byte) 0xb1, (byte) 0xb2, (byte) 0xb3, (byte) 0xb4,
+ (byte) 0xb5, (byte) 0xb6, (byte) 0xb7, (byte) 0xb8, (byte) 0xb9,
+ (byte) 0xba, (byte) 0xbb, (byte) 0xbc, (byte) 0xbd, (byte) 0xbe,
+ (byte) 0xbf, (byte) 0xc0, (byte) 0xc1, (byte) 0xc2, (byte) 0xc3,
+ (byte) 0xc4, (byte) 0xc5, (byte) 0xc6, (byte) 0xc7, (byte) 0xc8,
+ (byte) 0xc9, (byte) 0xca, (byte) 0xcb, (byte) 0xcc, (byte) 0xcd,
+ (byte) 0xce, (byte) 0xcf, (byte) 0xd0, (byte) 0xd1, (byte) 0xd2,
+ (byte) 0xd3, (byte) 0xd4, (byte) 0xd5, (byte) 0xd6, (byte) 0xd7,
+ (byte) 0xd8, (byte) 0xd9, (byte) 0xda, (byte) 0xdb, (byte) 0xdc,
+ (byte) 0xdd, (byte) 0xde, (byte) 0xdf, (byte) 0xe0, (byte) 0xe1,
+ (byte) 0xe2, (byte) 0xe3, (byte) 0xe4, (byte) 0xe5, (byte) 0xe6,
+ (byte) 0xe7, (byte) 0xe8, (byte) 0xe9, (byte) 0xea, (byte) 0xeb,
+ (byte) 0xec, (byte) 0xed, (byte) 0xee, (byte) 0xef, (byte) 0xf0,
+ (byte) 0xf1, (byte) 0xf2, (byte) 0xf3, (byte) 0xf4, (byte) 0xf5,
+ (byte) 0xf6, (byte) 0xf7, (byte) 0xf8, (byte) 0xf9, (byte) 0xfa,
+ (byte) 0xfb, (byte) 0xfc, (byte) 0xfd, (byte) 0xfe, (byte) 0xff};
+
+ byte[] okm = {(byte) 0xb1, (byte) 0x1e, (byte) 0x39, (byte) 0x8d, (byte) 0xc8,
+ (byte) 0x03, (byte) 0x27, (byte) 0xa1, (byte) 0xc8, (byte) 0xe7,
+ (byte) 0xf7, (byte) 0x8c, (byte) 0x59, (byte) 0x6a, (byte) 0x49,
+ (byte) 0x34, (byte) 0x4f, (byte) 0x01, (byte) 0x2e, (byte) 0xda,
+ (byte) 0x2d, (byte) 0x4e, (byte) 0xfa, (byte) 0xd8, (byte) 0xa0,
+ (byte) 0x50, (byte) 0xcc, (byte) 0x4c, (byte) 0x19, (byte) 0xaf,
+ (byte) 0xa9, (byte) 0x7c, (byte) 0x59, (byte) 0x04, (byte) 0x5a,
+ (byte) 0x99, (byte) 0xca, (byte) 0xc7, (byte) 0x82, (byte) 0x72,
+ (byte) 0x71, (byte) 0xcb, (byte) 0x41, (byte) 0xc6, (byte) 0x5e,
+ (byte) 0x59, (byte) 0x0e, (byte) 0x09, (byte) 0xda, (byte) 0x32,
+ (byte) 0x75, (byte) 0x60, (byte) 0x0c, (byte) 0x2f, (byte) 0x09,
+ (byte) 0xb8, (byte) 0x36, (byte) 0x77, (byte) 0x93, (byte) 0xa9,
+ (byte) 0xac, (byte) 0xa3, (byte) 0xdb, (byte) 0x71, (byte) 0xcc,
+ (byte) 0x30, (byte) 0xc5, (byte) 0x81, (byte) 0x79, (byte) 0xec,
+ (byte) 0x3e, (byte) 0x87, (byte) 0xc1, (byte) 0x4c, (byte) 0x01,
+ (byte) 0xd5, (byte) 0xc1, (byte) 0xf3, (byte) 0x43, (byte) 0x4f,
+ (byte) 0x1d, (byte) 0x87};
+
+ byte[] actualOutput = HKDF.createFor(3).deriveSecrets(ikm, salt, info, 82);
+ assertTrue(Arrays.equals(okm, actualOutput));
+ }
+
+ public void testVectorV2() {
+ byte[] ikm = {0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+ 0x0b, 0x0b};
+
+ byte[] salt = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+ 0x0a, 0x0b, 0x0c};
+
+ byte[] info = {(byte)0xf0, (byte)0xf1, (byte)0xf2, (byte)0xf3, (byte)0xf4,
+ (byte)0xf5, (byte)0xf6, (byte)0xf7, (byte)0xf8, (byte)0xf9};
+
+ byte[] okm = {(byte)0x6e, (byte)0xc2, (byte)0x55, (byte)0x6d, (byte)0x5d,
+ (byte)0x7b, (byte)0x1d, (byte)0x81, (byte)0xde, (byte)0xe4,
+ (byte)0x22, (byte)0x2a, (byte)0xd7, (byte)0x48, (byte)0x36,
+ (byte)0x95, (byte)0xdd, (byte)0xc9, (byte)0x8f, (byte)0x4f,
+ (byte)0x5f, (byte)0xab, (byte)0xc0, (byte)0xe0, (byte)0x20,
+ (byte)0x5d, (byte)0xc2, (byte)0xef, (byte)0x87, (byte)0x52,
+ (byte)0xd4, (byte)0x1e, (byte)0x04, (byte)0xe2, (byte)0xe2,
+ (byte)0x11, (byte)0x01, (byte)0xc6, (byte)0x8f, (byte)0xf0,
+ (byte)0x93, (byte)0x94, (byte)0xb8, (byte)0xad, (byte)0x0b,
+ (byte)0xdc, (byte)0xb9, (byte)0x60, (byte)0x9c, (byte)0xd4,
+ (byte)0xee, (byte)0x82, (byte)0xac, (byte)0x13, (byte)0x19,
+ (byte)0x9b, (byte)0x4a, (byte)0xa9, (byte)0xfd, (byte)0xa8,
+ (byte)0x99, (byte)0xda, (byte)0xeb, (byte)0xec};
+
+ byte[] actualOutput = HKDF.createFor(2).deriveSecrets(ikm, salt, info, 64);
+ assertTrue(Arrays.equals(okm, actualOutput));
+ }
+}
diff --git a/src/androidTest/java/org/whispersystems/test/ratchet/ChainKeyTest.java b/src/androidTest/java/org/whispersystems/test/ratchet/ChainKeyTest.java
new file mode 100644
index 00000000..1197f3eb
--- /dev/null
+++ b/src/androidTest/java/org/whispersystems/test/ratchet/ChainKeyTest.java
@@ -0,0 +1,59 @@
+package org.whispersystems.test.ratchet;
+
+import android.test.AndroidTestCase;
+
+import org.whispersystems.libaxolotl.kdf.HKDF;
+import org.whispersystems.libaxolotl.ratchet.ChainKey;
+
+import java.security.NoSuchAlgorithmException;
+import java.util.Arrays;
+
+public class ChainKeyTest extends AndroidTestCase {
+
+ public void testChainKeyDerivationV2() throws NoSuchAlgorithmException {
+
+ byte[] seed = {(byte) 0x8a, (byte) 0xb7, (byte) 0x2d, (byte) 0x6f, (byte) 0x4c,
+ (byte) 0xc5, (byte) 0xac, (byte) 0x0d, (byte) 0x38, (byte) 0x7e,
+ (byte) 0xaf, (byte) 0x46, (byte) 0x33, (byte) 0x78, (byte) 0xdd,
+ (byte) 0xb2, (byte) 0x8e, (byte) 0xdd, (byte) 0x07, (byte) 0x38,
+ (byte) 0x5b, (byte) 0x1c, (byte) 0xb0, (byte) 0x12, (byte) 0x50,
+ (byte) 0xc7, (byte) 0x15, (byte) 0x98, (byte) 0x2e, (byte) 0x7a,
+ (byte) 0xd4, (byte) 0x8f};
+
+ byte[] messageKey = {(byte) 0x02, (byte) 0xa9, (byte) 0xaa, (byte) 0x6c, (byte) 0x7d,
+ (byte) 0xbd, (byte) 0x64, (byte) 0xf9, (byte) 0xd3, (byte) 0xaa,
+ (byte) 0x92, (byte) 0xf9, (byte) 0x2a, (byte) 0x27, (byte) 0x7b,
+ (byte) 0xf5, (byte) 0x46, (byte) 0x09, (byte) 0xda, (byte) 0xdf,
+ (byte) 0x0b, (byte) 0x00, (byte) 0x82, (byte) 0x8a, (byte) 0xcf,
+ (byte) 0xc6, (byte) 0x1e, (byte) 0x3c, (byte) 0x72, (byte) 0x4b,
+ (byte) 0x84, (byte) 0xa7};
+
+ byte[] macKey = {(byte) 0xbf, (byte) 0xbe, (byte) 0x5e, (byte) 0xfb, (byte) 0x60,
+ (byte) 0x30, (byte) 0x30, (byte) 0x52, (byte) 0x67, (byte) 0x42,
+ (byte) 0xe3, (byte) 0xee, (byte) 0x89, (byte) 0xc7, (byte) 0x02,
+ (byte) 0x4e, (byte) 0x88, (byte) 0x4e, (byte) 0x44, (byte) 0x0f,
+ (byte) 0x1f, (byte) 0xf3, (byte) 0x76, (byte) 0xbb, (byte) 0x23,
+ (byte) 0x17, (byte) 0xb2, (byte) 0xd6, (byte) 0x4d, (byte) 0xeb,
+ (byte) 0x7c, (byte) 0x83};
+
+ byte[] nextChainKey = {(byte) 0x28, (byte) 0xe8, (byte) 0xf8, (byte) 0xfe, (byte) 0xe5,
+ (byte) 0x4b, (byte) 0x80, (byte) 0x1e, (byte) 0xef, (byte) 0x7c,
+ (byte) 0x5c, (byte) 0xfb, (byte) 0x2f, (byte) 0x17, (byte) 0xf3,
+ (byte) 0x2c, (byte) 0x7b, (byte) 0x33, (byte) 0x44, (byte) 0x85,
+ (byte) 0xbb, (byte) 0xb7, (byte) 0x0f, (byte) 0xac, (byte) 0x6e,
+ (byte) 0xc1, (byte) 0x03, (byte) 0x42, (byte) 0xa2, (byte) 0x46,
+ (byte) 0xd1, (byte) 0x5d};
+
+ ChainKey chainKey = new ChainKey(HKDF.createFor(2), seed, 0);
+
+ assertTrue(Arrays.equals(chainKey.getKey(), seed));
+ assertTrue(Arrays.equals(chainKey.getMessageKeys().getCipherKey().getEncoded(), messageKey));
+ assertTrue(Arrays.equals(chainKey.getMessageKeys().getMacKey().getEncoded(), macKey));
+ assertTrue(Arrays.equals(chainKey.getNextChainKey().getKey(), nextChainKey));
+ assertTrue(chainKey.getIndex() == 0);
+ assertTrue(chainKey.getMessageKeys().getCounter() == 0);
+ assertTrue(chainKey.getNextChainKey().getIndex() == 1);
+ assertTrue(chainKey.getNextChainKey().getMessageKeys().getCounter() == 1);
+ }
+
+}
diff --git a/src/androidTest/java/org/whispersystems/test/ratchet/RatchetingSessionTest.java b/src/androidTest/java/org/whispersystems/test/ratchet/RatchetingSessionTest.java
new file mode 100644
index 00000000..311aff90
--- /dev/null
+++ b/src/androidTest/java/org/whispersystems/test/ratchet/RatchetingSessionTest.java
@@ -0,0 +1,236 @@
+package org.whispersystems.test.ratchet;
+
+import android.test.AndroidTestCase;
+import android.util.Log;
+
+import org.whispersystems.libaxolotl.IdentityKey;
+import org.whispersystems.libaxolotl.IdentityKeyPair;
+import org.whispersystems.libaxolotl.InvalidKeyException;
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.ecc.ECPrivateKey;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+import org.whispersystems.libaxolotl.ratchet.AliceAxolotlParameters;
+import org.whispersystems.libaxolotl.ratchet.BobAxolotlParameters;
+import org.whispersystems.libaxolotl.ratchet.RatchetingSession;
+import org.whispersystems.libaxolotl.state.SessionState;
+import org.whispersystems.libaxolotl.util.Hex;
+import org.whispersystems.libaxolotl.util.guava.Optional;
+
+import java.util.Arrays;
+
+public class RatchetingSessionTest extends AndroidTestCase {
+
+ public void testRatchetingSessionAsBob() throws InvalidKeyException {
+ byte[] bobPublic = {(byte) 0x05, (byte) 0x2c, (byte) 0xb4, (byte) 0x97,
+ (byte) 0x76, (byte) 0xb8, (byte) 0x77, (byte) 0x02,
+ (byte) 0x05, (byte) 0x74, (byte) 0x5a, (byte) 0x3a,
+ (byte) 0x6e, (byte) 0x24, (byte) 0xf5, (byte) 0x79,
+ (byte) 0xcd, (byte) 0xb4, (byte) 0xba, (byte) 0x7a,
+ (byte) 0x89, (byte) 0x04, (byte) 0x10, (byte) 0x05,
+ (byte) 0x92, (byte) 0x8e, (byte) 0xbb, (byte) 0xad,
+ (byte) 0xc9, (byte) 0xc0, (byte) 0x5a, (byte) 0xd4,
+ (byte) 0x58};
+
+ byte[] bobPrivate = {(byte) 0xa1, (byte) 0xca, (byte) 0xb4, (byte) 0x8f,
+ (byte) 0x7c, (byte) 0x89, (byte) 0x3f, (byte) 0xaf,
+ (byte) 0xa9, (byte) 0x88, (byte) 0x0a, (byte) 0x28,
+ (byte) 0xc3, (byte) 0xb4, (byte) 0x99, (byte) 0x9d,
+ (byte) 0x28, (byte) 0xd6, (byte) 0x32, (byte) 0x95,
+ (byte) 0x62, (byte) 0xd2, (byte) 0x7a, (byte) 0x4e,
+ (byte) 0xa4, (byte) 0xe2, (byte) 0x2e, (byte) 0x9f,
+ (byte) 0xf1, (byte) 0xbd, (byte) 0xd6, (byte) 0x5a};
+
+ byte[] bobIdentityPublic = {(byte) 0x05, (byte) 0xf1, (byte) 0xf4, (byte) 0x38,
+ (byte) 0x74, (byte) 0xf6, (byte) 0x96, (byte) 0x69,
+ (byte) 0x56, (byte) 0xc2, (byte) 0xdd, (byte) 0x47,
+ (byte) 0x3f, (byte) 0x8f, (byte) 0xa1, (byte) 0x5a,
+ (byte) 0xde, (byte) 0xb7, (byte) 0x1d, (byte) 0x1c,
+ (byte) 0xb9, (byte) 0x91, (byte) 0xb2, (byte) 0x34,
+ (byte) 0x16, (byte) 0x92, (byte) 0x32, (byte) 0x4c,
+ (byte) 0xef, (byte) 0xb1, (byte) 0xc5, (byte) 0xe6,
+ (byte) 0x26};
+
+ byte[] bobIdentityPrivate = {(byte) 0x48, (byte) 0x75, (byte) 0xcc, (byte) 0x69,
+ (byte) 0xdd, (byte) 0xf8, (byte) 0xea, (byte) 0x07,
+ (byte) 0x19, (byte) 0xec, (byte) 0x94, (byte) 0x7d,
+ (byte) 0x61, (byte) 0x08, (byte) 0x11, (byte) 0x35,
+ (byte) 0x86, (byte) 0x8d, (byte) 0x5f, (byte) 0xd8,
+ (byte) 0x01, (byte) 0xf0, (byte) 0x2c, (byte) 0x02,
+ (byte) 0x25, (byte) 0xe5, (byte) 0x16, (byte) 0xdf,
+ (byte) 0x21, (byte) 0x56, (byte) 0x60, (byte) 0x5e};
+
+ byte[] aliceBasePublic = {(byte) 0x05, (byte) 0x47, (byte) 0x2d, (byte) 0x1f,
+ (byte) 0xb1, (byte) 0xa9, (byte) 0x86, (byte) 0x2c,
+ (byte) 0x3a, (byte) 0xf6, (byte) 0xbe, (byte) 0xac,
+ (byte) 0xa8, (byte) 0x92, (byte) 0x02, (byte) 0x77,
+ (byte) 0xe2, (byte) 0xb2, (byte) 0x6f, (byte) 0x4a,
+ (byte) 0x79, (byte) 0x21, (byte) 0x3e, (byte) 0xc7,
+ (byte) 0xc9, (byte) 0x06, (byte) 0xae, (byte) 0xb3,
+ (byte) 0x5e, (byte) 0x03, (byte) 0xcf, (byte) 0x89,
+ (byte) 0x50};
+
+ byte[] aliceEphemeralPublic = {(byte) 0x05, (byte) 0x6c, (byte) 0x3e, (byte) 0x0d,
+ (byte) 0x1f, (byte) 0x52, (byte) 0x02, (byte) 0x83,
+ (byte) 0xef, (byte) 0xcc, (byte) 0x55, (byte) 0xfc,
+ (byte) 0xa5, (byte) 0xe6, (byte) 0x70, (byte) 0x75,
+ (byte) 0xb9, (byte) 0x04, (byte) 0x00, (byte) 0x7f,
+ (byte) 0x18, (byte) 0x81, (byte) 0xd1, (byte) 0x51,
+ (byte) 0xaf, (byte) 0x76, (byte) 0xdf, (byte) 0x18,
+ (byte) 0xc5, (byte) 0x1d, (byte) 0x29, (byte) 0xd3,
+ (byte) 0x4b};
+
+ byte[] aliceIdentityPublic = {(byte) 0x05, (byte) 0xb4, (byte) 0xa8, (byte) 0x45,
+ (byte) 0x56, (byte) 0x60, (byte) 0xad, (byte) 0xa6,
+ (byte) 0x5b, (byte) 0x40, (byte) 0x10, (byte) 0x07,
+ (byte) 0xf6, (byte) 0x15, (byte) 0xe6, (byte) 0x54,
+ (byte) 0x04, (byte) 0x17, (byte) 0x46, (byte) 0x43,
+ (byte) 0x2e, (byte) 0x33, (byte) 0x39, (byte) 0xc6,
+ (byte) 0x87, (byte) 0x51, (byte) 0x49, (byte) 0xbc,
+ (byte) 0xee, (byte) 0xfc, (byte) 0xb4, (byte) 0x2b,
+ (byte) 0x4a};
+
+ byte[] senderChain = {(byte)0xd2, (byte)0x2f, (byte)0xd5, (byte)0x6d, (byte)0x3f,
+ (byte)0xec, (byte)0x81, (byte)0x9c, (byte)0xf4, (byte)0xc3,
+ (byte)0xd5, (byte)0x0c, (byte)0x56, (byte)0xed, (byte)0xfb,
+ (byte)0x1c, (byte)0x28, (byte)0x0a, (byte)0x1b, (byte)0x31,
+ (byte)0x96, (byte)0x45, (byte)0x37, (byte)0xf1, (byte)0xd1,
+ (byte)0x61, (byte)0xe1, (byte)0xc9, (byte)0x31, (byte)0x48,
+ (byte)0xe3, (byte)0x6b};
+
+ IdentityKey bobIdentityKeyPublic = new IdentityKey(bobIdentityPublic, 0);
+ ECPrivateKey bobIdentityKeyPrivate = Curve.decodePrivatePoint(bobIdentityPrivate);
+ IdentityKeyPair bobIdentityKey = new IdentityKeyPair(bobIdentityKeyPublic, bobIdentityKeyPrivate);
+ ECPublicKey bobEphemeralPublicKey = Curve.decodePoint(bobPublic, 0);
+ ECPrivateKey bobEphemeralPrivateKey = Curve.decodePrivatePoint(bobPrivate);
+ ECKeyPair bobEphemeralKey = new ECKeyPair(bobEphemeralPublicKey, bobEphemeralPrivateKey);
+ ECKeyPair bobBaseKey = bobEphemeralKey;
+
+ ECPublicKey aliceBasePublicKey = Curve.decodePoint(aliceBasePublic, 0);
+ ECPublicKey aliceEphemeralPublicKey = Curve.decodePoint(aliceEphemeralPublic, 0);
+ IdentityKey aliceIdentityPublicKey = new IdentityKey(aliceIdentityPublic, 0);
+
+ BobAxolotlParameters parameters = BobAxolotlParameters.newBuilder()
+ .setOurIdentityKey(bobIdentityKey)
+ .setOurSignedPreKey(bobBaseKey)
+ .setOurRatchetKey(bobEphemeralKey)
+ .setOurOneTimePreKey(Optional.<ECKeyPair>absent())
+ .setTheirIdentityKey(aliceIdentityPublicKey)
+ .setTheirBaseKey(aliceBasePublicKey)
+ .create();
+
+ SessionState session = new SessionState();
+
+ RatchetingSession.initializeSession(session, 2, parameters);
+
+ assertTrue(session.getLocalIdentityKey().equals(bobIdentityKey.getPublicKey()));
+ assertTrue(session.getRemoteIdentityKey().equals(aliceIdentityPublicKey));
+ assertTrue(Arrays.equals(session.getSenderChainKey().getKey(), senderChain));
+ }
+
+ public void testRatchetingSessionAsAlice() throws InvalidKeyException {
+ byte[] bobPublic = {(byte) 0x05, (byte) 0x2c, (byte) 0xb4, (byte) 0x97, (byte) 0x76,
+ (byte) 0xb8, (byte) 0x77, (byte) 0x02, (byte) 0x05, (byte) 0x74,
+ (byte) 0x5a, (byte) 0x3a, (byte) 0x6e, (byte) 0x24, (byte) 0xf5,
+ (byte) 0x79, (byte) 0xcd, (byte) 0xb4, (byte) 0xba, (byte) 0x7a,
+ (byte) 0x89, (byte) 0x04, (byte) 0x10, (byte) 0x05, (byte) 0x92,
+ (byte) 0x8e, (byte) 0xbb, (byte) 0xad, (byte) 0xc9, (byte) 0xc0,
+ (byte) 0x5a, (byte) 0xd4, (byte) 0x58};
+
+ byte[] bobIdentityPublic = {(byte) 0x05, (byte) 0xf1, (byte) 0xf4, (byte) 0x38, (byte) 0x74,
+ (byte) 0xf6, (byte) 0x96, (byte) 0x69, (byte) 0x56, (byte) 0xc2,
+ (byte) 0xdd, (byte) 0x47, (byte) 0x3f, (byte) 0x8f, (byte) 0xa1,
+ (byte) 0x5a, (byte) 0xde, (byte) 0xb7, (byte) 0x1d, (byte) 0x1c,
+ (byte) 0xb9, (byte) 0x91, (byte) 0xb2, (byte) 0x34, (byte) 0x16,
+ (byte) 0x92, (byte) 0x32, (byte) 0x4c, (byte) 0xef, (byte) 0xb1,
+ (byte) 0xc5, (byte) 0xe6, (byte) 0x26};
+
+ byte[] aliceBasePublic = {(byte) 0x05, (byte) 0x47, (byte) 0x2d, (byte) 0x1f, (byte) 0xb1,
+ (byte) 0xa9, (byte) 0x86, (byte) 0x2c, (byte) 0x3a, (byte) 0xf6,
+ (byte) 0xbe, (byte) 0xac, (byte) 0xa8, (byte) 0x92, (byte) 0x02,
+ (byte) 0x77, (byte) 0xe2, (byte) 0xb2, (byte) 0x6f, (byte) 0x4a,
+ (byte) 0x79, (byte) 0x21, (byte) 0x3e, (byte) 0xc7, (byte) 0xc9,
+ (byte) 0x06, (byte) 0xae, (byte) 0xb3, (byte) 0x5e, (byte) 0x03,
+ (byte) 0xcf, (byte) 0x89, (byte) 0x50};
+
+ byte[] aliceBasePrivate = {(byte) 0x11, (byte) 0xae, (byte) 0x7c, (byte) 0x64, (byte) 0xd1,
+ (byte) 0xe6, (byte) 0x1c, (byte) 0xd5, (byte) 0x96, (byte) 0xb7,
+ (byte) 0x6a, (byte) 0x0d, (byte) 0xb5, (byte) 0x01, (byte) 0x26,
+ (byte) 0x73, (byte) 0x39, (byte) 0x1c, (byte) 0xae, (byte) 0x66,
+ (byte) 0xed, (byte) 0xbf, (byte) 0xcf, (byte) 0x07, (byte) 0x3b,
+ (byte) 0x4d, (byte) 0xa8, (byte) 0x05, (byte) 0x16, (byte) 0xa4,
+ (byte) 0x74, (byte) 0x49};
+
+ byte[] aliceEphemeralPublic = {(byte) 0x05, (byte) 0x6c, (byte) 0x3e, (byte) 0x0d, (byte) 0x1f,
+ (byte) 0x52, (byte) 0x02, (byte) 0x83, (byte) 0xef, (byte) 0xcc,
+ (byte) 0x55, (byte) 0xfc, (byte) 0xa5, (byte) 0xe6, (byte) 0x70,
+ (byte) 0x75, (byte) 0xb9, (byte) 0x04, (byte) 0x00, (byte) 0x7f,
+ (byte) 0x18, (byte) 0x81, (byte) 0xd1, (byte) 0x51, (byte) 0xaf,
+ (byte) 0x76, (byte) 0xdf, (byte) 0x18, (byte) 0xc5, (byte) 0x1d,
+ (byte) 0x29, (byte) 0xd3, (byte) 0x4b};
+
+ byte[] aliceEphemeralPrivate = {(byte) 0xd1, (byte) 0xba, (byte) 0x38, (byte) 0xce, (byte) 0xa9,
+ (byte) 0x17, (byte) 0x43, (byte) 0xd3, (byte) 0x39, (byte) 0x39,
+ (byte) 0xc3, (byte) 0x3c, (byte) 0x84, (byte) 0x98, (byte) 0x65,
+ (byte) 0x09, (byte) 0x28, (byte) 0x01, (byte) 0x61, (byte) 0xb8,
+ (byte) 0xb6, (byte) 0x0f, (byte) 0xc7, (byte) 0x87, (byte) 0x0c,
+ (byte) 0x59, (byte) 0x9c, (byte) 0x1d, (byte) 0x46, (byte) 0x20,
+ (byte) 0x12, (byte) 0x48};
+
+ byte[] aliceIdentityPublic = {(byte) 0x05, (byte) 0xb4, (byte) 0xa8, (byte) 0x45, (byte) 0x56,
+ (byte) 0x60, (byte) 0xad, (byte) 0xa6, (byte) 0x5b, (byte) 0x40,
+ (byte) 0x10, (byte) 0x07, (byte) 0xf6, (byte) 0x15, (byte) 0xe6,
+ (byte) 0x54, (byte) 0x04, (byte) 0x17, (byte) 0x46, (byte) 0x43,
+ (byte) 0x2e, (byte) 0x33, (byte) 0x39, (byte) 0xc6, (byte) 0x87,
+ (byte) 0x51, (byte) 0x49, (byte) 0xbc, (byte) 0xee, (byte) 0xfc,
+ (byte) 0xb4, (byte) 0x2b, (byte) 0x4a};
+
+ byte[] aliceIdentityPrivate = {(byte) 0x90, (byte) 0x40, (byte) 0xf0, (byte) 0xd4, (byte) 0xe0,
+ (byte) 0x9c, (byte) 0xf3, (byte) 0x8f, (byte) 0x6d, (byte) 0xc7,
+ (byte) 0xc1, (byte) 0x37, (byte) 0x79, (byte) 0xc9, (byte) 0x08,
+ (byte) 0xc0, (byte) 0x15, (byte) 0xa1, (byte) 0xda, (byte) 0x4f,
+ (byte) 0xa7, (byte) 0x87, (byte) 0x37, (byte) 0xa0, (byte) 0x80,
+ (byte) 0xeb, (byte) 0x0a, (byte) 0x6f, (byte) 0x4f, (byte) 0x5f,
+ (byte) 0x8f, (byte) 0x58};
+
+ byte[] receiverChain = {(byte) 0xd2, (byte) 0x2f, (byte) 0xd5, (byte) 0x6d, (byte) 0x3f,
+ (byte) 0xec, (byte) 0x81, (byte) 0x9c, (byte) 0xf4, (byte) 0xc3,
+ (byte) 0xd5, (byte) 0x0c, (byte) 0x56, (byte) 0xed, (byte) 0xfb,
+ (byte) 0x1c, (byte) 0x28, (byte) 0x0a, (byte) 0x1b, (byte) 0x31,
+ (byte) 0x96, (byte) 0x45, (byte) 0x37, (byte) 0xf1, (byte) 0xd1,
+ (byte) 0x61, (byte) 0xe1, (byte) 0xc9, (byte) 0x31, (byte) 0x48,
+ (byte) 0xe3, (byte) 0x6b};
+
+ IdentityKey bobIdentityKey = new IdentityKey(bobIdentityPublic, 0);
+ ECPublicKey bobEphemeralPublicKey = Curve.decodePoint(bobPublic, 0);
+ ECPublicKey bobBasePublicKey = bobEphemeralPublicKey;
+ ECPublicKey aliceBasePublicKey = Curve.decodePoint(aliceBasePublic, 0);
+ ECPrivateKey aliceBasePrivateKey = Curve.decodePrivatePoint(aliceBasePrivate);
+ ECKeyPair aliceBaseKey = new ECKeyPair(aliceBasePublicKey, aliceBasePrivateKey);
+ ECPublicKey aliceEphemeralPublicKey = Curve.decodePoint(aliceEphemeralPublic, 0);
+ ECPrivateKey aliceEphemeralPrivateKey = Curve.decodePrivatePoint(aliceEphemeralPrivate);
+ ECKeyPair aliceEphemeralKey = new ECKeyPair(aliceEphemeralPublicKey, aliceEphemeralPrivateKey);
+ IdentityKey aliceIdentityPublicKey = new IdentityKey(aliceIdentityPublic, 0);
+ ECPrivateKey aliceIdentityPrivateKey = Curve.decodePrivatePoint(aliceIdentityPrivate);
+ IdentityKeyPair aliceIdentityKey = new IdentityKeyPair(aliceIdentityPublicKey, aliceIdentityPrivateKey);
+
+ SessionState session = new SessionState();
+
+ AliceAxolotlParameters parameters = AliceAxolotlParameters.newBuilder()
+ .setOurBaseKey(aliceBaseKey)
+ .setOurIdentityKey(aliceIdentityKey)
+ .setTheirIdentityKey(bobIdentityKey)
+ .setTheirSignedPreKey(bobBasePublicKey)
+ .setTheirRatchetKey(bobEphemeralPublicKey)
+ .setTheirOneTimePreKey(Optional.<ECPublicKey>absent())
+ .create();
+
+ RatchetingSession.initializeSession(session, 2, parameters);
+
+ assertTrue(session.getLocalIdentityKey().equals(aliceIdentityKey.getPublicKey()));
+ assertTrue(session.getRemoteIdentityKey().equals(bobIdentityKey));
+ assertTrue(Arrays.equals(session.getReceiverChainKey(bobEphemeralPublicKey).getKey(),
+ receiverChain));
+
+ }
+}
diff --git a/src/androidTest/java/org/whispersystems/test/ratchet/RootKeyTest.java b/src/androidTest/java/org/whispersystems/test/ratchet/RootKeyTest.java
new file mode 100644
index 00000000..c48ef23d
--- /dev/null
+++ b/src/androidTest/java/org/whispersystems/test/ratchet/RootKeyTest.java
@@ -0,0 +1,84 @@
+package org.whispersystems.test.ratchet;
+
+import android.test.AndroidTestCase;
+
+import org.whispersystems.libaxolotl.InvalidKeyException;
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.ecc.ECPrivateKey;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+import org.whispersystems.libaxolotl.kdf.HKDF;
+import org.whispersystems.libaxolotl.ratchet.ChainKey;
+import org.whispersystems.libaxolotl.ratchet.RootKey;
+import org.whispersystems.libaxolotl.util.Pair;
+
+import java.security.NoSuchAlgorithmException;
+import java.util.Arrays;
+
+public class RootKeyTest extends AndroidTestCase {
+
+ public void testRootKeyDerivationV2() throws NoSuchAlgorithmException, InvalidKeyException {
+ byte[] rootKeySeed = {(byte) 0x7b, (byte) 0xa6, (byte) 0xde, (byte) 0xbc, (byte) 0x2b,
+ (byte) 0xc1, (byte) 0xbb, (byte) 0xf9, (byte) 0x1a, (byte) 0xbb,
+ (byte) 0xc1, (byte) 0x36, (byte) 0x74, (byte) 0x04, (byte) 0x17,
+ (byte) 0x6c, (byte) 0xa6, (byte) 0x23, (byte) 0x09, (byte) 0x5b,
+ (byte) 0x7e, (byte) 0xc6, (byte) 0x6b, (byte) 0x45, (byte) 0xf6,
+ (byte) 0x02, (byte) 0xd9, (byte) 0x35, (byte) 0x38, (byte) 0x94,
+ (byte) 0x2d, (byte) 0xcc};
+
+ byte[] alicePublic = {(byte) 0x05, (byte) 0xee, (byte) 0x4f, (byte) 0xa6, (byte) 0xcd,
+ (byte) 0xc0, (byte) 0x30, (byte) 0xdf, (byte) 0x49, (byte) 0xec,
+ (byte) 0xd0, (byte) 0xba, (byte) 0x6c, (byte) 0xfc, (byte) 0xff,
+ (byte) 0xb2, (byte) 0x33, (byte) 0xd3, (byte) 0x65, (byte) 0xa2,
+ (byte) 0x7f, (byte) 0xad, (byte) 0xbe, (byte) 0xff, (byte) 0x77,
+ (byte) 0xe9, (byte) 0x63, (byte) 0xfc, (byte) 0xb1, (byte) 0x62,
+ (byte) 0x22, (byte) 0xe1, (byte) 0x3a};
+
+ byte[] alicePrivate = {(byte) 0x21, (byte) 0x68, (byte) 0x22, (byte) 0xec, (byte) 0x67,
+ (byte) 0xeb, (byte) 0x38, (byte) 0x04, (byte) 0x9e, (byte) 0xba,
+ (byte) 0xe7, (byte) 0xb9, (byte) 0x39, (byte) 0xba, (byte) 0xea,
+ (byte) 0xeb, (byte) 0xb1, (byte) 0x51, (byte) 0xbb, (byte) 0xb3,
+ (byte) 0x2d, (byte) 0xb8, (byte) 0x0f, (byte) 0xd3, (byte) 0x89,
+ (byte) 0x24, (byte) 0x5a, (byte) 0xc3, (byte) 0x7a, (byte) 0x94,
+ (byte) 0x8e, (byte) 0x50};
+
+ byte[] bobPublic = {(byte) 0x05, (byte) 0xab, (byte) 0xb8, (byte) 0xeb, (byte) 0x29,
+ (byte) 0xcc, (byte) 0x80, (byte) 0xb4, (byte) 0x71, (byte) 0x09,
+ (byte) 0xa2, (byte) 0x26, (byte) 0x5a, (byte) 0xbe, (byte) 0x97,
+ (byte) 0x98, (byte) 0x48, (byte) 0x54, (byte) 0x06, (byte) 0xe3,
+ (byte) 0x2d, (byte) 0xa2, (byte) 0x68, (byte) 0x93, (byte) 0x4a,
+ (byte) 0x95, (byte) 0x55, (byte) 0xe8, (byte) 0x47, (byte) 0x57,
+ (byte) 0x70, (byte) 0x8a, (byte) 0x30};
+
+ byte[] nextRoot = {(byte) 0xb1, (byte) 0x14, (byte) 0xf5, (byte) 0xde, (byte) 0x28,
+ (byte) 0x01, (byte) 0x19, (byte) 0x85, (byte) 0xe6, (byte) 0xeb,
+ (byte) 0xa2, (byte) 0x5d, (byte) 0x50, (byte) 0xe7, (byte) 0xec,
+ (byte) 0x41, (byte) 0xa9, (byte) 0xb0, (byte) 0x2f, (byte) 0x56,
+ (byte) 0x93, (byte) 0xc5, (byte) 0xc7, (byte) 0x88, (byte) 0xa6,
+ (byte) 0x3a, (byte) 0x06, (byte) 0xd2, (byte) 0x12, (byte) 0xa2,
+ (byte) 0xf7, (byte) 0x31};
+
+ byte[] nextChain = {(byte) 0x9d, (byte) 0x7d, (byte) 0x24, (byte) 0x69, (byte) 0xbc,
+ (byte) 0x9a, (byte) 0xe5, (byte) 0x3e, (byte) 0xe9, (byte) 0x80,
+ (byte) 0x5a, (byte) 0xa3, (byte) 0x26, (byte) 0x4d, (byte) 0x24,
+ (byte) 0x99, (byte) 0xa3, (byte) 0xac, (byte) 0xe8, (byte) 0x0f,
+ (byte) 0x4c, (byte) 0xca, (byte) 0xe2, (byte) 0xda, (byte) 0x13,
+ (byte) 0x43, (byte) 0x0c, (byte) 0x5c, (byte) 0x55, (byte) 0xb5,
+ (byte) 0xca, (byte) 0x5f};
+
+ ECPublicKey alicePublicKey = Curve.decodePoint(alicePublic, 0);
+ ECPrivateKey alicePrivateKey = Curve.decodePrivatePoint(alicePrivate);
+ ECKeyPair aliceKeyPair = new ECKeyPair(alicePublicKey, alicePrivateKey);
+
+ ECPublicKey bobPublicKey = Curve.decodePoint(bobPublic, 0);
+ RootKey rootKey = new RootKey(HKDF.createFor(2), rootKeySeed);
+
+ Pair<RootKey, ChainKey> rootKeyChainKeyPair = rootKey.createChain(bobPublicKey, aliceKeyPair);
+ RootKey nextRootKey = rootKeyChainKeyPair.first();
+ ChainKey nextChainKey = rootKeyChainKeyPair.second();
+
+ assertTrue(Arrays.equals(rootKey.getKeyBytes(), rootKeySeed));
+ assertTrue(Arrays.equals(nextRootKey.getKeyBytes(), nextRoot));
+ assertTrue(Arrays.equals(nextChainKey.getKey(), nextChain));
+ }
+}
diff --git a/src/main/AndroidManifest.xml b/src/main/AndroidManifest.xml
new file mode 100644
index 00000000..28d28168
--- /dev/null
+++ b/src/main/AndroidManifest.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="org.whispersystems.libaxolotl"
+ android:versionCode="1"
+ android:versionName="0.1">
+ <application />
+</manifest>
diff --git a/src/main/java/org/whispersystems/libaxolotl/DuplicateMessageException.java b/src/main/java/org/whispersystems/libaxolotl/DuplicateMessageException.java
new file mode 100644
index 00000000..913c0121
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/DuplicateMessageException.java
@@ -0,0 +1,7 @@
+package org.whispersystems.libaxolotl;
+
+public class DuplicateMessageException extends Exception {
+ public DuplicateMessageException(String s) {
+ super(s);
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/IdentityKey.java b/src/main/java/org/whispersystems/libaxolotl/IdentityKey.java
new file mode 100644
index 00000000..35af3394
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/IdentityKey.java
@@ -0,0 +1,66 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl;
+
+
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+import org.whispersystems.libaxolotl.util.Hex;
+
+/**
+ * A class for representing an identity key.
+ *
+ * @author Moxie Marlinspike
+ */
+
+public class IdentityKey {
+
+ private final ECPublicKey publicKey;
+
+ public IdentityKey(ECPublicKey publicKey) {
+ this.publicKey = publicKey;
+ }
+
+ public IdentityKey(byte[] bytes, int offset) throws InvalidKeyException {
+ this.publicKey = Curve.decodePoint(bytes, offset);
+ }
+
+ public ECPublicKey getPublicKey() {
+ return publicKey;
+ }
+
+ public byte[] serialize() {
+ return publicKey.serialize();
+ }
+
+ public String getFingerprint() {
+ return Hex.toString(publicKey.serialize());
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (other == null) return false;
+ if (!(other instanceof IdentityKey)) return false;
+
+ return publicKey.equals(((IdentityKey) other).getPublicKey());
+ }
+
+ @Override
+ public int hashCode() {
+ return publicKey.hashCode();
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/IdentityKeyPair.java b/src/main/java/org/whispersystems/libaxolotl/IdentityKeyPair.java
new file mode 100644
index 00000000..c47df4bc
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/IdentityKeyPair.java
@@ -0,0 +1,66 @@
+/**
+ * Copyright (C) 2013 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECPrivateKey;
+
+import static org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure;
+
+/**
+ * Holder for public and private identity key pair.
+ *
+ * @author Moxie Marlinspike
+ */
+public class IdentityKeyPair {
+
+ private final IdentityKey publicKey;
+ private final ECPrivateKey privateKey;
+
+ public IdentityKeyPair(IdentityKey publicKey, ECPrivateKey privateKey) {
+ this.publicKey = publicKey;
+ this.privateKey = privateKey;
+ }
+
+ public IdentityKeyPair(byte[] serialized) throws InvalidKeyException {
+ try {
+ IdentityKeyPairStructure structure = IdentityKeyPairStructure.parseFrom(serialized);
+ this.publicKey = new IdentityKey(structure.getPublicKey().toByteArray(), 0);
+ this.privateKey = Curve.decodePrivatePoint(structure.getPrivateKey().toByteArray());
+ } catch (InvalidProtocolBufferException e) {
+ throw new InvalidKeyException(e);
+ }
+ }
+
+ public IdentityKey getPublicKey() {
+ return publicKey;
+ }
+
+ public ECPrivateKey getPrivateKey() {
+ return privateKey;
+ }
+
+ public byte[] serialize() {
+ return IdentityKeyPairStructure.newBuilder()
+ .setPublicKey(ByteString.copyFrom(publicKey.serialize()))
+ .setPrivateKey(ByteString.copyFrom(privateKey.serialize()))
+ .build().toByteArray();
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/InvalidKeyException.java b/src/main/java/org/whispersystems/libaxolotl/InvalidKeyException.java
new file mode 100644
index 00000000..bb70df16
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/InvalidKeyException.java
@@ -0,0 +1,34 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl;
+
+public class InvalidKeyException extends Exception {
+
+ public InvalidKeyException() {}
+
+ public InvalidKeyException(String detailMessage) {
+ super(detailMessage);
+ }
+
+ public InvalidKeyException(Throwable throwable) {
+ super(throwable);
+ }
+
+ public InvalidKeyException(String detailMessage, Throwable throwable) {
+ super(detailMessage, throwable);
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/InvalidKeyIdException.java b/src/main/java/org/whispersystems/libaxolotl/InvalidKeyIdException.java
new file mode 100644
index 00000000..c7c6bc01
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/InvalidKeyIdException.java
@@ -0,0 +1,27 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl;
+
+public class InvalidKeyIdException extends Exception {
+ public InvalidKeyIdException(String detailMessage) {
+ super(detailMessage);
+ }
+
+ public InvalidKeyIdException(Throwable throwable) {
+ super(throwable);
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/InvalidMacException.java b/src/main/java/org/whispersystems/libaxolotl/InvalidMacException.java
new file mode 100644
index 00000000..0afc6996
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/InvalidMacException.java
@@ -0,0 +1,28 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl;
+
+public class InvalidMacException extends Exception {
+
+ public InvalidMacException(String detailMessage) {
+ super(detailMessage);
+ }
+
+ public InvalidMacException(Throwable throwable) {
+ super(throwable);
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/InvalidMessageException.java b/src/main/java/org/whispersystems/libaxolotl/InvalidMessageException.java
new file mode 100644
index 00000000..063eb594
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/InvalidMessageException.java
@@ -0,0 +1,40 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl;
+
+import java.util.List;
+
+public class InvalidMessageException extends Exception {
+
+ public InvalidMessageException() {}
+
+ public InvalidMessageException(String detailMessage) {
+ super(detailMessage);
+ }
+
+ public InvalidMessageException(Throwable throwable) {
+ super(throwable);
+ }
+
+ public InvalidMessageException(String detailMessage, Throwable throwable) {
+ super(detailMessage, throwable);
+ }
+
+ public InvalidMessageException(String detailMessage, List<Exception> exceptions) {
+ super(detailMessage, exceptions.get(0));
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/InvalidVersionException.java b/src/main/java/org/whispersystems/libaxolotl/InvalidVersionException.java
new file mode 100644
index 00000000..a1324443
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/InvalidVersionException.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl;
+
+public class InvalidVersionException extends Exception {
+ public InvalidVersionException(String detailMessage) {
+ super(detailMessage);
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/LegacyMessageException.java b/src/main/java/org/whispersystems/libaxolotl/LegacyMessageException.java
new file mode 100644
index 00000000..dadde754
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/LegacyMessageException.java
@@ -0,0 +1,7 @@
+package org.whispersystems.libaxolotl;
+
+public class LegacyMessageException extends Exception {
+ public LegacyMessageException(String s) {
+ super(s);
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/NoSessionException.java b/src/main/java/org/whispersystems/libaxolotl/NoSessionException.java
new file mode 100644
index 00000000..16203554
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/NoSessionException.java
@@ -0,0 +1,11 @@
+package org.whispersystems.libaxolotl;
+
+public class NoSessionException extends Exception {
+ public NoSessionException(String s) {
+ super(s);
+ }
+
+ public NoSessionException(Exception nested) {
+ super(nested);
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/SessionBuilder.java b/src/main/java/org/whispersystems/libaxolotl/SessionBuilder.java
new file mode 100644
index 00000000..2d1c8969
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/SessionBuilder.java
@@ -0,0 +1,411 @@
+package org.whispersystems.libaxolotl;
+
+import android.util.Log;
+
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+import org.whispersystems.libaxolotl.protocol.CiphertextMessage;
+import org.whispersystems.libaxolotl.protocol.KeyExchangeMessage;
+import org.whispersystems.libaxolotl.protocol.PreKeyWhisperMessage;
+import org.whispersystems.libaxolotl.ratchet.AliceAxolotlParameters;
+import org.whispersystems.libaxolotl.ratchet.BobAxolotlParameters;
+import org.whispersystems.libaxolotl.ratchet.RatchetingSession;
+import org.whispersystems.libaxolotl.ratchet.SymmetricAxolotlParameters;
+import org.whispersystems.libaxolotl.state.AxolotlStore;
+import org.whispersystems.libaxolotl.state.IdentityKeyStore;
+import org.whispersystems.libaxolotl.state.PreKeyBundle;
+import org.whispersystems.libaxolotl.state.PreKeyStore;
+import org.whispersystems.libaxolotl.state.SessionRecord;
+import org.whispersystems.libaxolotl.state.SessionState;
+import org.whispersystems.libaxolotl.state.SessionStore;
+import org.whispersystems.libaxolotl.state.SignedPreKeyStore;
+import org.whispersystems.libaxolotl.util.KeyHelper;
+import org.whispersystems.libaxolotl.util.Medium;
+import org.whispersystems.libaxolotl.util.guava.Optional;
+
+/**
+ * SessionBuilder is responsible for setting up encrypted sessions.
+ * Once a session has been established, {@link org.whispersystems.libaxolotl.SessionCipher}
+ * can be used to encrypt/decrypt messages in that session.
+ * <p>
+ * Sessions are built from one of three different possible vectors:
+ * <ol>
+ * <li>A {@link org.whispersystems.libaxolotl.state.PreKeyBundle} retrieved from a server.</li>
+ * <li>A {@link org.whispersystems.libaxolotl.protocol.PreKeyWhisperMessage} received from a client.</li>
+ * <li>A {@link org.whispersystems.libaxolotl.protocol.KeyExchangeMessage} sent to or received from a client.</li>
+ * </ol>
+ *
+ * Sessions are constructed per recipientId + deviceId tuple. Remote logical users are identified
+ * by their recipientId, and each logical recipientId can have multiple physical devices.
+ *
+ * @author Moxie Marlinspike
+ */
+public class SessionBuilder {
+
+ private static final String TAG = SessionBuilder.class.getSimpleName();
+
+ private final SessionStore sessionStore;
+ private final PreKeyStore preKeyStore;
+ private final SignedPreKeyStore signedPreKeyStore;
+ private final IdentityKeyStore identityKeyStore;
+ private final long recipientId;
+ private final int deviceId;
+
+ /**
+ * Constructs a SessionBuilder.
+ *
+ * @param sessionStore The {@link org.whispersystems.libaxolotl.state.SessionStore} to store the constructed session in.
+ * @param preKeyStore The {@link org.whispersystems.libaxolotl.state.PreKeyStore} where the client's local {@link org.whispersystems.libaxolotl.state.PreKeyRecord}s are stored.
+ * @param identityKeyStore The {@link org.whispersystems.libaxolotl.state.IdentityKeyStore} containing the client's identity key information.
+ * @param recipientId The recipient ID of the remote user to build a session with.
+ * @param deviceId The device ID of the remote user's physical device.
+ */
+ public SessionBuilder(SessionStore sessionStore,
+ PreKeyStore preKeyStore,
+ SignedPreKeyStore signedPreKeyStore,
+ IdentityKeyStore identityKeyStore,
+ long recipientId, int deviceId)
+ {
+ this.sessionStore = sessionStore;
+ this.preKeyStore = preKeyStore;
+ this.signedPreKeyStore = signedPreKeyStore;
+ this.identityKeyStore = identityKeyStore;
+ this.recipientId = recipientId;
+ this.deviceId = deviceId;
+ }
+
+ /**
+ * Constructs a SessionBuilder
+ * @param store The {@link org.whispersystems.libaxolotl.state.AxolotlStore} to store all state information in.
+ * @param recipientId The recipient ID of the remote user to build a session with.
+ * @param deviceId The device ID of the remote user's physical device.
+ */
+ public SessionBuilder(AxolotlStore store, long recipientId, int deviceId) {
+ this(store, store, store, store, recipientId, deviceId);
+ }
+
+ /**
+ * Build a new session from a received {@link org.whispersystems.libaxolotl.protocol.PreKeyWhisperMessage}.
+ *
+ * After a session is constructed in this way, the embedded {@link org.whispersystems.libaxolotl.protocol.WhisperMessage}
+ * can be decrypted.
+ *
+ * @param message The received {@link org.whispersystems.libaxolotl.protocol.PreKeyWhisperMessage}.
+ * @throws org.whispersystems.libaxolotl.InvalidKeyIdException when there is no local
+ * {@link org.whispersystems.libaxolotl.state.PreKeyRecord}
+ * that corresponds to the PreKey ID in
+ * the message.
+ * @throws org.whispersystems.libaxolotl.InvalidKeyException when the message is formatted incorrectly.
+ * @throws org.whispersystems.libaxolotl.UntrustedIdentityException when the {@link IdentityKey} of the sender is untrusted.
+ */
+ /*package*/ Optional<Integer> process(SessionRecord sessionRecord, PreKeyWhisperMessage message)
+ throws InvalidKeyIdException, InvalidKeyException, UntrustedIdentityException
+ {
+ int messageVersion = message.getMessageVersion();
+ IdentityKey theirIdentityKey = message.getIdentityKey();
+
+ Optional<Integer> unsignedPreKeyId;
+
+ if (!identityKeyStore.isTrustedIdentity(recipientId, theirIdentityKey)) {
+ throw new UntrustedIdentityException();
+ }
+
+ switch (messageVersion) {
+ case 2: unsignedPreKeyId = processV2(sessionRecord, message); break;
+ case 3: unsignedPreKeyId = processV3(sessionRecord, message); break;
+ default: throw new AssertionError("Unknown version: " + messageVersion);
+ }
+
+ identityKeyStore.saveIdentity(recipientId, theirIdentityKey);
+ return unsignedPreKeyId;
+ }
+
+ private Optional<Integer> processV3(SessionRecord sessionRecord, PreKeyWhisperMessage message)
+ throws UntrustedIdentityException, InvalidKeyIdException, InvalidKeyException
+ {
+
+ if (sessionRecord.hasSessionState(message.getMessageVersion(), message.getBaseKey().serialize())) {
+ Log.w(TAG, "We've already setup a session for this V3 message, letting bundled message fall through...");
+ return Optional.absent();
+ }
+
+ ECKeyPair ourSignedPreKey = signedPreKeyStore.loadSignedPreKey(message.getSignedPreKeyId()).getKeyPair();
+
+ BobAxolotlParameters.Builder parameters = BobAxolotlParameters.newBuilder();
+
+ parameters.setTheirBaseKey(message.getBaseKey())
+ .setTheirIdentityKey(message.getIdentityKey())
+ .setOurIdentityKey(identityKeyStore.getIdentityKeyPair())
+ .setOurSignedPreKey(ourSignedPreKey)
+ .setOurRatchetKey(ourSignedPreKey);
+
+ if (message.getPreKeyId().isPresent()) {
+ parameters.setOurOneTimePreKey(Optional.of(preKeyStore.loadPreKey(message.getPreKeyId().get()).getKeyPair()));
+ } else {
+ parameters.setOurOneTimePreKey(Optional.<ECKeyPair>absent());
+ }
+
+ if (!sessionRecord.isFresh()) sessionRecord.archiveCurrentState();
+
+ RatchetingSession.initializeSession(sessionRecord.getSessionState(), message.getMessageVersion(), parameters.create());
+
+ sessionRecord.getSessionState().setLocalRegistrationId(identityKeyStore.getLocalRegistrationId());
+ sessionRecord.getSessionState().setRemoteRegistrationId(message.getRegistrationId());
+ sessionRecord.getSessionState().setAliceBaseKey(message.getBaseKey().serialize());
+
+ if (message.getPreKeyId().isPresent() && message.getPreKeyId().get() != Medium.MAX_VALUE) {
+ return message.getPreKeyId();
+ } else {
+ return Optional.absent();
+ }
+ }
+
+ private Optional<Integer> processV2(SessionRecord sessionRecord, PreKeyWhisperMessage message)
+ throws UntrustedIdentityException, InvalidKeyIdException, InvalidKeyException
+ {
+ if (!message.getPreKeyId().isPresent()) {
+ throw new InvalidKeyIdException("V2 message requires one time prekey id!");
+ }
+
+ if (!preKeyStore.containsPreKey(message.getPreKeyId().get()) &&
+ sessionStore.containsSession(recipientId, deviceId))
+ {
+ Log.w(TAG, "We've already processed the prekey part of this V2 session, letting bundled message fall through...");
+ return Optional.absent();
+ }
+
+ ECKeyPair ourPreKey = preKeyStore.loadPreKey(message.getPreKeyId().get()).getKeyPair();
+
+ BobAxolotlParameters.Builder parameters = BobAxolotlParameters.newBuilder();
+
+ parameters.setOurIdentityKey(identityKeyStore.getIdentityKeyPair())
+ .setOurSignedPreKey(ourPreKey)
+ .setOurRatchetKey(ourPreKey)
+ .setOurOneTimePreKey(Optional.<ECKeyPair>absent())
+ .setTheirIdentityKey(message.getIdentityKey())
+ .setTheirBaseKey(message.getBaseKey());
+
+ if (!sessionRecord.isFresh()) sessionRecord.archiveCurrentState();
+
+ RatchetingSession.initializeSession(sessionRecord.getSessionState(), message.getMessageVersion(), parameters.create());
+
+ sessionRecord.getSessionState().setLocalRegistrationId(identityKeyStore.getLocalRegistrationId());
+ sessionRecord.getSessionState().setRemoteRegistrationId(message.getRegistrationId());
+ sessionRecord.getSessionState().setAliceBaseKey(message.getBaseKey().serialize());
+
+ if (message.getPreKeyId().get() != Medium.MAX_VALUE) {
+ return message.getPreKeyId();
+ } else {
+ return Optional.absent();
+ }
+ }
+
+ /**
+ * Build a new session from a {@link org.whispersystems.libaxolotl.state.PreKeyBundle} retrieved from
+ * a server.
+ *
+ * @param preKey A PreKey for the destination recipient, retrieved from a server.
+ * @throws InvalidKeyException when the {@link org.whispersystems.libaxolotl.state.PreKeyBundle} is
+ * badly formatted.
+ * @throws org.whispersystems.libaxolotl.UntrustedIdentityException when the sender's
+ * {@link IdentityKey} is not
+ * trusted.
+ */
+ public void process(PreKeyBundle preKey) throws InvalidKeyException, UntrustedIdentityException {
+ synchronized (SessionCipher.SESSION_LOCK) {
+ if (!identityKeyStore.isTrustedIdentity(recipientId, preKey.getIdentityKey())) {
+ throw new UntrustedIdentityException();
+ }
+
+ if (preKey.getSignedPreKey() != null &&
+ !Curve.verifySignature(preKey.getIdentityKey().getPublicKey(),
+ preKey.getSignedPreKey().serialize(),
+ preKey.getSignedPreKeySignature()))
+ {
+ throw new InvalidKeyException("Invalid signature on device key!");
+ }
+
+ if (preKey.getSignedPreKey() == null && preKey.getPreKey() == null) {
+ throw new InvalidKeyException("Both signed and unsigned prekeys are absent!");
+ }
+
+ boolean supportsV3 = preKey.getSignedPreKey() != null;
+ SessionRecord sessionRecord = sessionStore.loadSession(recipientId, deviceId);
+ ECKeyPair ourBaseKey = Curve.generateKeyPair();
+ ECPublicKey theirSignedPreKey = supportsV3 ? preKey.getSignedPreKey() : preKey.getPreKey();
+ Optional<ECPublicKey> theirOneTimePreKey = Optional.fromNullable(preKey.getPreKey());
+ Optional<Integer> theirOneTimePreKeyId = theirOneTimePreKey.isPresent() ? Optional.of(preKey.getPreKeyId()) :
+ Optional.<Integer>absent();
+
+ AliceAxolotlParameters.Builder parameters = AliceAxolotlParameters.newBuilder();
+
+ parameters.setOurBaseKey(ourBaseKey)
+ .setOurIdentityKey(identityKeyStore.getIdentityKeyPair())
+ .setTheirIdentityKey(preKey.getIdentityKey())
+ .setTheirSignedPreKey(theirSignedPreKey)
+ .setTheirRatchetKey(theirSignedPreKey)
+ .setTheirOneTimePreKey(supportsV3 ? theirOneTimePreKey : Optional.<ECPublicKey>absent());
+
+ if (!sessionRecord.isFresh()) sessionRecord.archiveCurrentState();
+
+ RatchetingSession.initializeSession(sessionRecord.getSessionState(),
+ supportsV3 ? 3 : 2,
+ parameters.create());
+
+ sessionRecord.getSessionState().setUnacknowledgedPreKeyMessage(theirOneTimePreKeyId, preKey.getSignedPreKeyId(), ourBaseKey.getPublicKey());
+ sessionRecord.getSessionState().setLocalRegistrationId(identityKeyStore.getLocalRegistrationId());
+ sessionRecord.getSessionState().setRemoteRegistrationId(preKey.getRegistrationId());
+ sessionRecord.getSessionState().setAliceBaseKey(ourBaseKey.getPublicKey().serialize());
+
+ sessionStore.storeSession(recipientId, deviceId, sessionRecord);
+ identityKeyStore.saveIdentity(recipientId, preKey.getIdentityKey());
+ }
+ }
+
+ /**
+ * Build a new session from a {@link org.whispersystems.libaxolotl.protocol.KeyExchangeMessage}
+ * received from a remote client.
+ *
+ * @param message The received KeyExchangeMessage.
+ * @return The KeyExchangeMessage to respond with, or null if no response is necessary.
+ * @throws InvalidKeyException if the received KeyExchangeMessage is badly formatted.
+ */
+ public KeyExchangeMessage process(KeyExchangeMessage message)
+ throws InvalidKeyException, UntrustedIdentityException, StaleKeyExchangeException
+ {
+ synchronized (SessionCipher.SESSION_LOCK) {
+ if (!identityKeyStore.isTrustedIdentity(recipientId, message.getIdentityKey())) {
+ throw new UntrustedIdentityException();
+ }
+
+ KeyExchangeMessage responseMessage = null;
+
+ if (message.isInitiate()) responseMessage = processInitiate(message);
+ else processResponse(message);
+
+ return responseMessage;
+ }
+ }
+
+ private KeyExchangeMessage processInitiate(KeyExchangeMessage message) throws InvalidKeyException {
+ int flags = KeyExchangeMessage.RESPONSE_FLAG;
+ SessionRecord sessionRecord = sessionStore.loadSession(recipientId, deviceId);
+
+ if (message.getVersion() >= 3 &&
+ !Curve.verifySignature(message.getIdentityKey().getPublicKey(),
+ message.getBaseKey().serialize(),
+ message.getBaseKeySignature()))
+ {
+ throw new InvalidKeyException("Bad signature!");
+ }
+
+ SymmetricAxolotlParameters.Builder builder = SymmetricAxolotlParameters.newBuilder();
+
+ if (!sessionRecord.getSessionState().hasPendingKeyExchange()) {
+ builder.setOurIdentityKey(identityKeyStore.getIdentityKeyPair())
+ .setOurBaseKey(Curve.generateKeyPair())
+ .setOurRatchetKey(Curve.generateKeyPair());
+ } else {
+ builder.setOurIdentityKey(sessionRecord.getSessionState().getPendingKeyExchangeIdentityKey())
+ .setOurBaseKey(sessionRecord.getSessionState().getPendingKeyExchangeBaseKey())
+ .setOurRatchetKey(sessionRecord.getSessionState().getPendingKeyExchangeRatchetKey());
+ flags |= KeyExchangeMessage.SIMULTAENOUS_INITIATE_FLAG;
+ }
+
+ builder.setTheirBaseKey(message.getBaseKey())
+ .setTheirRatchetKey(message.getRatchetKey())
+ .setTheirIdentityKey(message.getIdentityKey());
+
+ SymmetricAxolotlParameters parameters = builder.create();
+
+ if (!sessionRecord.isFresh()) sessionRecord.archiveCurrentState();
+
+ RatchetingSession.initializeSession(sessionRecord.getSessionState(),
+ Math.min(message.getMaxVersion(), CiphertextMessage.CURRENT_VERSION),
+ parameters);
+
+ sessionStore.storeSession(recipientId, deviceId, sessionRecord);
+ identityKeyStore.saveIdentity(recipientId, message.getIdentityKey());
+
+ byte[] baseKeySignature = Curve.calculateSignature(parameters.getOurIdentityKey().getPrivateKey(),
+ parameters.getOurBaseKey().getPublicKey().serialize());
+
+ return new KeyExchangeMessage(sessionRecord.getSessionState().getSessionVersion(),
+ message.getSequence(), flags,
+ parameters.getOurBaseKey().getPublicKey(),
+ baseKeySignature, parameters.getOurRatchetKey().getPublicKey(),
+ parameters.getOurIdentityKey().getPublicKey());
+ }
+
+ private void processResponse(KeyExchangeMessage message)
+ throws StaleKeyExchangeException, InvalidKeyException
+ {
+ SessionRecord sessionRecord = sessionStore.loadSession(recipientId, deviceId);
+ SessionState sessionState = sessionRecord.getSessionState();
+ boolean hasPendingKeyExchange = sessionState.hasPendingKeyExchange();
+ boolean isSimultaneousInitiateResponse = message.isResponseForSimultaneousInitiate();
+
+ if (!hasPendingKeyExchange || sessionState.getPendingKeyExchangeSequence() != message.getSequence()) {
+ Log.w(TAG, "No matching sequence for response. Is simultaneous initiate response: " + isSimultaneousInitiateResponse);
+ if (!isSimultaneousInitiateResponse) throw new StaleKeyExchangeException();
+ else return;
+ }
+
+ SymmetricAxolotlParameters.Builder parameters = SymmetricAxolotlParameters.newBuilder();
+
+ parameters.setOurBaseKey(sessionRecord.getSessionState().getPendingKeyExchangeBaseKey())
+ .setOurRatchetKey(sessionRecord.getSessionState().getPendingKeyExchangeRatchetKey())
+ .setOurIdentityKey(sessionRecord.getSessionState().getPendingKeyExchangeIdentityKey())
+ .setTheirBaseKey(message.getBaseKey())
+ .setTheirRatchetKey(message.getRatchetKey())
+ .setTheirIdentityKey(message.getIdentityKey());
+
+ if (!sessionRecord.isFresh()) sessionRecord.archiveCurrentState();
+
+ RatchetingSession.initializeSession(sessionRecord.getSessionState(),
+ Math.min(message.getMaxVersion(), CiphertextMessage.CURRENT_VERSION),
+ parameters.create());
+
+ if (sessionRecord.getSessionState().getSessionVersion() >= 3 &&
+ !Curve.verifySignature(message.getIdentityKey().getPublicKey(),
+ message.getBaseKey().serialize(),
+ message.getBaseKeySignature()))
+ {
+ throw new InvalidKeyException("Base key signature doesn't match!");
+ }
+
+ sessionStore.storeSession(recipientId, deviceId, sessionRecord);
+ identityKeyStore.saveIdentity(recipientId, message.getIdentityKey());
+
+ }
+
+ /**
+ * 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(recipientId, deviceId);
+
+ sessionRecord.getSessionState().setPendingKeyExchange(sequence, baseKey, ratchetKey, identityKey);
+ sessionStore.storeSession(recipientId, deviceId, sessionRecord);
+
+ return new KeyExchangeMessage(2, sequence, flags, baseKey.getPublicKey(), baseKeySignature,
+ ratchetKey.getPublicKey(), identityKey.getPublicKey());
+ } catch (InvalidKeyException e) {
+ throw new AssertionError(e);
+ }
+ }
+ }
+
+
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/SessionCipher.java b/src/main/java/org/whispersystems/libaxolotl/SessionCipher.java
new file mode 100644
index 00000000..381dedb8
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/SessionCipher.java
@@ -0,0 +1,469 @@
+/**
+ * Copyright (C) 2013 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl;
+
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+import org.whispersystems.libaxolotl.protocol.CiphertextMessage;
+import org.whispersystems.libaxolotl.protocol.PreKeyWhisperMessage;
+import org.whispersystems.libaxolotl.protocol.WhisperMessage;
+import org.whispersystems.libaxolotl.ratchet.ChainKey;
+import org.whispersystems.libaxolotl.ratchet.MessageKeys;
+import org.whispersystems.libaxolotl.ratchet.RootKey;
+import org.whispersystems.libaxolotl.state.AxolotlStore;
+import org.whispersystems.libaxolotl.state.IdentityKeyStore;
+import org.whispersystems.libaxolotl.state.PreKeyStore;
+import org.whispersystems.libaxolotl.state.SessionRecord;
+import org.whispersystems.libaxolotl.state.SessionState;
+import org.whispersystems.libaxolotl.state.SessionStore;
+import org.whispersystems.libaxolotl.state.SignedPreKeyStore;
+import org.whispersystems.libaxolotl.util.ByteUtil;
+import org.whispersystems.libaxolotl.util.Pair;
+import org.whispersystems.libaxolotl.util.guava.Optional;
+
+import java.security.InvalidAlgorithmParameterException;
+import java.security.NoSuchAlgorithmException;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+
+import static org.whispersystems.libaxolotl.state.SessionState.UnacknowledgedPreKeyMessageItems;
+
+/**
+ * The main entry point for Axolotl encrypt/decrypt operations.
+ *
+ * Once a session has been established with {@link SessionBuilder},
+ * this class can be used for all encrypt/decrypt operations within
+ * that session.
+ *
+ * @author Moxie Marlinspike
+ */
+public class SessionCipher {
+
+ public static final Object SESSION_LOCK = new Object();
+
+ private final SessionStore sessionStore;
+ private final SessionBuilder sessionBuilder;
+ private final PreKeyStore preKeyStore;
+ private final long recipientId;
+ private final int deviceId;
+
+ /**
+ * Construct a SessionCipher for encrypt/decrypt operations on a session.
+ * In order to use SessionCipher, a session must have already been created
+ * and stored using {@link SessionBuilder}.
+ *
+ * @param sessionStore The {@link SessionStore} that contains a session for this recipient.
+ * @param recipientId The remote ID that messages will be encrypted to or decrypted from.
+ * @param deviceId The device corresponding to the recipientId.
+ */
+ public SessionCipher(SessionStore sessionStore, PreKeyStore preKeyStore,
+ SignedPreKeyStore signedPreKeyStore, IdentityKeyStore identityKeyStore,
+ long recipientId, int deviceId)
+ {
+ this.sessionStore = sessionStore;
+ this.recipientId = recipientId;
+ this.deviceId = deviceId;
+ this.preKeyStore = preKeyStore;
+ this.sessionBuilder = new SessionBuilder(sessionStore, preKeyStore, signedPreKeyStore,
+ identityKeyStore, recipientId, deviceId);
+ }
+
+ public SessionCipher(AxolotlStore store, long recipientId, int deviceId) {
+ this(store, store, store, store, recipientId, deviceId);
+ }
+
+ /**
+ * Encrypt a message.
+ *
+ * @param paddedMessage The plaintext message bytes, optionally padded to a constant multiple.
+ * @return A ciphertext message encrypted to the recipient+device tuple.
+ */
+ public CiphertextMessage encrypt(byte[] paddedMessage) {
+ synchronized (SESSION_LOCK) {
+ SessionRecord sessionRecord = sessionStore.loadSession(recipientId, deviceId);
+ SessionState sessionState = sessionRecord.getSessionState();
+ ChainKey chainKey = sessionState.getSenderChainKey();
+ MessageKeys messageKeys = chainKey.getMessageKeys();
+ ECPublicKey senderEphemeral = sessionState.getSenderRatchetKey();
+ int previousCounter = sessionState.getPreviousCounter();
+ int sessionVersion = sessionState.getSessionVersion();
+
+ byte[] ciphertextBody = getCiphertext(sessionVersion, messageKeys, paddedMessage);
+ CiphertextMessage ciphertextMessage = new WhisperMessage(sessionVersion, messageKeys.getMacKey(),
+ senderEphemeral, chainKey.getIndex(),
+ previousCounter, ciphertextBody,
+ sessionState.getLocalIdentityKey(),
+ sessionState.getRemoteIdentityKey());
+
+ if (sessionState.hasUnacknowledgedPreKeyMessage()) {
+ UnacknowledgedPreKeyMessageItems items = sessionState.getUnacknowledgedPreKeyMessageItems();
+ int localRegistrationId = sessionState.getLocalRegistrationId();
+
+ ciphertextMessage = new PreKeyWhisperMessage(sessionVersion, localRegistrationId, items.getPreKeyId(),
+ items.getSignedPreKeyId(), items.getBaseKey(),
+ sessionState.getLocalIdentityKey(),
+ (WhisperMessage) ciphertextMessage);
+ }
+
+ sessionState.setSenderChainKey(chainKey.getNextChainKey());
+ sessionStore.storeSession(recipientId, deviceId, sessionRecord);
+ return ciphertextMessage;
+ }
+ }
+
+ /**
+ * Decrypt a message.
+ *
+ * @param ciphertext The {@link PreKeyWhisperMessage} to decrypt.
+ *
+ * @return The plaintext.
+ * @throws InvalidMessageException if the input is not valid ciphertext.
+ * @throws DuplicateMessageException if the input is a message that has already been received.
+ * @throws LegacyMessageException if the input is a message formatted by a protocol version that
+ * is no longer supported.
+ * @throws InvalidKeyIdException when there is no local {@link org.whispersystems.libaxolotl.state.PreKeyRecord}
+ * that corresponds to the PreKey ID in the message.
+ * @throws InvalidKeyException when the message is formatted incorrectly.
+ * @throws UntrustedIdentityException when the {@link IdentityKey} of the sender is untrusted.
+ */
+ public byte[] decrypt(PreKeyWhisperMessage ciphertext)
+ throws DuplicateMessageException, LegacyMessageException, InvalidMessageException,
+ InvalidKeyIdException, InvalidKeyException, UntrustedIdentityException
+ {
+ return decrypt(ciphertext, new NullDecryptionCallback());
+ }
+
+ /**
+ * Decrypt a message.
+ *
+ * @param ciphertext The {@link PreKeyWhisperMessage} to decrypt.
+ * @param callback A callback that is triggered after decryption is complete,
+ * but before the updated session state has been committed to the session
+ * DB. This allows some implementations to store the committed plaintext
+ * to a DB first, in case they are concerned with a crash happening between
+ * the time the session state is updated but before they're able to store
+ * the plaintext to disk.
+ *
+ * @return The plaintext.
+ * @throws InvalidMessageException if the input is not valid ciphertext.
+ * @throws DuplicateMessageException if the input is a message that has already been received.
+ * @throws LegacyMessageException if the input is a message formatted by a protocol version that
+ * is no longer supported.
+ * @throws InvalidKeyIdException when there is no local {@link org.whispersystems.libaxolotl.state.PreKeyRecord}
+ * that corresponds to the PreKey ID in the message.
+ * @throws InvalidKeyException when the message is formatted incorrectly.
+ * @throws UntrustedIdentityException when the {@link IdentityKey} of the sender is untrusted.
+ */
+ public byte[] decrypt(PreKeyWhisperMessage ciphertext, DecryptionCallback callback)
+ throws DuplicateMessageException, LegacyMessageException, InvalidMessageException,
+ InvalidKeyIdException, InvalidKeyException, UntrustedIdentityException
+ {
+ synchronized (SESSION_LOCK) {
+ SessionRecord sessionRecord = sessionStore.loadSession(recipientId, deviceId);
+ Optional<Integer> unsignedPreKeyId = sessionBuilder.process(sessionRecord, ciphertext);
+ byte[] plaintext = decrypt(sessionRecord, ciphertext.getWhisperMessage());
+
+ callback.handlePlaintext(plaintext);
+
+ sessionStore.storeSession(recipientId, deviceId, sessionRecord);
+
+ if (unsignedPreKeyId.isPresent()) {
+ preKeyStore.removePreKey(unsignedPreKeyId.get());
+ }
+
+ return plaintext;
+ }
+ }
+
+ /**
+ * Decrypt a message.
+ *
+ * @param ciphertext The {@link WhisperMessage} to decrypt.
+ *
+ * @return The plaintext.
+ * @throws InvalidMessageException if the input is not valid ciphertext.
+ * @throws DuplicateMessageException if the input is a message that has already been received.
+ * @throws LegacyMessageException if the input is a message formatted by a protocol version that
+ * is no longer supported.
+ * @throws NoSessionException if there is no established session for this contact.
+ */
+ public byte[] decrypt(WhisperMessage ciphertext)
+ throws InvalidMessageException, DuplicateMessageException, LegacyMessageException,
+ NoSessionException
+ {
+ return decrypt(ciphertext, new NullDecryptionCallback());
+ }
+
+ /**
+ * Decrypt a message.
+ *
+ * @param ciphertext The {@link WhisperMessage} to decrypt.
+ * @param callback A callback that is triggered after decryption is complete,
+ * but before the updated session state has been committed to the session
+ * DB. This allows some implementations to store the committed plaintext
+ * to a DB first, in case they are concerned with a crash happening between
+ * the time the session state is updated but before they're able to store
+ * the plaintext to disk.
+ *
+ * @return The plaintext.
+ * @throws InvalidMessageException if the input is not valid ciphertext.
+ * @throws DuplicateMessageException if the input is a message that has already been received.
+ * @throws LegacyMessageException if the input is a message formatted by a protocol version that
+ * is no longer supported.
+ * @throws NoSessionException if there is no established session for this contact.
+ */
+ public byte[] decrypt(WhisperMessage ciphertext, DecryptionCallback callback)
+ throws InvalidMessageException, DuplicateMessageException, LegacyMessageException,
+ NoSessionException
+ {
+ synchronized (SESSION_LOCK) {
+
+ if (!sessionStore.containsSession(recipientId, deviceId)) {
+ throw new NoSessionException("No session for: " + recipientId + ", " + deviceId);
+ }
+
+ SessionRecord sessionRecord = sessionStore.loadSession(recipientId, deviceId);
+ byte[] plaintext = decrypt(sessionRecord, ciphertext);
+
+ callback.handlePlaintext(plaintext);
+
+ sessionStore.storeSession(recipientId, deviceId, sessionRecord);
+
+ return plaintext;
+ }
+ }
+
+ private byte[] decrypt(SessionRecord sessionRecord, WhisperMessage ciphertext)
+ throws DuplicateMessageException, LegacyMessageException, InvalidMessageException
+ {
+ synchronized (SESSION_LOCK) {
+ Iterator<SessionState> previousStates = sessionRecord.getPreviousSessionStates().iterator();
+ List<Exception> exceptions = new LinkedList<>();
+
+ try {
+ SessionState sessionState = new SessionState(sessionRecord.getSessionState());
+ byte[] plaintext = decrypt(sessionState, ciphertext);
+
+ sessionRecord.setState(sessionState);
+ return plaintext;
+ } catch (InvalidMessageException e) {
+ exceptions.add(e);
+ }
+
+ while (previousStates.hasNext()) {
+ try {
+ SessionState promotedState = new SessionState(previousStates.next());
+ byte[] plaintext = decrypt(promotedState, ciphertext);
+
+ previousStates.remove();
+ sessionRecord.promoteState(promotedState);
+
+ return plaintext;
+ } catch (InvalidMessageException e) {
+ exceptions.add(e);
+ }
+ }
+
+ throw new InvalidMessageException("No valid sessions.", exceptions);
+ }
+ }
+
+ private byte[] decrypt(SessionState sessionState, WhisperMessage ciphertextMessage)
+ throws InvalidMessageException, DuplicateMessageException, LegacyMessageException
+ {
+ if (!sessionState.hasSenderChain()) {
+ throw new InvalidMessageException("Uninitialized session!");
+ }
+
+ if (ciphertextMessage.getMessageVersion() != sessionState.getSessionVersion()) {
+ throw new InvalidMessageException(String.format("Message version %d, but session version %d",
+ ciphertextMessage.getMessageVersion(),
+ sessionState.getSessionVersion()));
+ }
+
+ int messageVersion = ciphertextMessage.getMessageVersion();
+ ECPublicKey theirEphemeral = ciphertextMessage.getSenderRatchetKey();
+ int counter = ciphertextMessage.getCounter();
+ ChainKey chainKey = getOrCreateChainKey(sessionState, theirEphemeral);
+ MessageKeys messageKeys = getOrCreateMessageKeys(sessionState, theirEphemeral,
+ chainKey, counter);
+
+ ciphertextMessage.verifyMac(messageVersion,
+ sessionState.getRemoteIdentityKey(),
+ sessionState.getLocalIdentityKey(),
+ messageKeys.getMacKey());
+
+ byte[] plaintext = getPlaintext(messageVersion, messageKeys, ciphertextMessage.getBody());
+
+ sessionState.clearUnacknowledgedPreKeyMessage();
+
+ return plaintext;
+ }
+
+ public int getRemoteRegistrationId() {
+ synchronized (SESSION_LOCK) {
+ SessionRecord record = sessionStore.loadSession(recipientId, deviceId);
+ return record.getSessionState().getRemoteRegistrationId();
+ }
+ }
+
+ public int getSessionVersion() {
+ synchronized (SESSION_LOCK) {
+ if (!sessionStore.containsSession(recipientId, deviceId)) {
+ throw new IllegalStateException(String.format("No session for (%d, %d)!", recipientId, deviceId));
+ }
+
+ SessionRecord record = sessionStore.loadSession(recipientId, deviceId);
+ return record.getSessionState().getSessionVersion();
+ }
+ }
+
+ private ChainKey getOrCreateChainKey(SessionState sessionState, ECPublicKey theirEphemeral)
+ throws InvalidMessageException
+ {
+ try {
+ if (sessionState.hasReceiverChain(theirEphemeral)) {
+ return sessionState.getReceiverChainKey(theirEphemeral);
+ } else {
+ RootKey rootKey = sessionState.getRootKey();
+ ECKeyPair ourEphemeral = sessionState.getSenderRatchetKeyPair();
+ Pair<RootKey, ChainKey> receiverChain = rootKey.createChain(theirEphemeral, ourEphemeral);
+ ECKeyPair ourNewEphemeral = Curve.generateKeyPair();
+ Pair<RootKey, ChainKey> senderChain = receiverChain.first().createChain(theirEphemeral, ourNewEphemeral);
+
+ sessionState.setRootKey(senderChain.first());
+ sessionState.addReceiverChain(theirEphemeral, receiverChain.second());
+ sessionState.setPreviousCounter(Math.max(sessionState.getSenderChainKey().getIndex()-1, 0));
+ sessionState.setSenderChain(ourNewEphemeral, senderChain.second());
+
+ return receiverChain.second();
+ }
+ } catch (InvalidKeyException e) {
+ throw new InvalidMessageException(e);
+ }
+ }
+
+ private MessageKeys getOrCreateMessageKeys(SessionState sessionState,
+ ECPublicKey theirEphemeral,
+ ChainKey chainKey, int counter)
+ throws InvalidMessageException, DuplicateMessageException
+ {
+ if (chainKey.getIndex() > counter) {
+ if (sessionState.hasMessageKeys(theirEphemeral, counter)) {
+ return sessionState.removeMessageKeys(theirEphemeral, counter);
+ } else {
+ throw new DuplicateMessageException("Received message with old counter: " +
+ chainKey.getIndex() + " , " + counter);
+ }
+ }
+
+ if (counter - chainKey.getIndex() > 2000) {
+ throw new InvalidMessageException("Over 2000 messages into the future!");
+ }
+
+ while (chainKey.getIndex() < counter) {
+ MessageKeys messageKeys = chainKey.getMessageKeys();
+ sessionState.setMessageKeys(theirEphemeral, messageKeys);
+ chainKey = chainKey.getNextChainKey();
+ }
+
+ sessionState.setReceiverChainKey(theirEphemeral, chainKey.getNextChainKey());
+ return chainKey.getMessageKeys();
+ }
+
+ private byte[] getCiphertext(int version, MessageKeys messageKeys, byte[] plaintext) {
+ try {
+ Cipher cipher;
+
+ if (version >= 3) {
+ cipher = getCipher(Cipher.ENCRYPT_MODE, messageKeys.getCipherKey(), messageKeys.getIv());
+ } else {
+ cipher = getCipher(Cipher.ENCRYPT_MODE, messageKeys.getCipherKey(), messageKeys.getCounter());
+ }
+
+ return cipher.doFinal(plaintext);
+ } catch (IllegalBlockSizeException | BadPaddingException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ private byte[] getPlaintext(int version, MessageKeys messageKeys, byte[] cipherText)
+ throws InvalidMessageException
+ {
+ try {
+ Cipher cipher;
+
+ if (version >= 3) {
+ cipher = getCipher(Cipher.DECRYPT_MODE, messageKeys.getCipherKey(), messageKeys.getIv());
+ } else {
+ cipher = getCipher(Cipher.DECRYPT_MODE, messageKeys.getCipherKey(), messageKeys.getCounter());
+ }
+
+ return cipher.doFinal(cipherText);
+ } catch (IllegalBlockSizeException | BadPaddingException e) {
+ throw new InvalidMessageException(e);
+ }
+ }
+
+ private Cipher getCipher(int mode, SecretKeySpec key, int counter) {
+ try {
+ Cipher cipher = Cipher.getInstance("AES/CTR/NoPadding");
+
+ byte[] ivBytes = new byte[16];
+ ByteUtil.intToByteArray(ivBytes, 0, counter);
+
+ IvParameterSpec iv = new IvParameterSpec(ivBytes);
+ cipher.init(mode, key, iv);
+
+ return cipher;
+ } catch (NoSuchAlgorithmException | NoSuchPaddingException | java.security.InvalidKeyException |
+ InvalidAlgorithmParameterException e)
+ {
+ throw new AssertionError(e);
+ }
+ }
+
+ private Cipher getCipher(int mode, SecretKeySpec key, IvParameterSpec iv) {
+ try {
+ Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
+ cipher.init(mode, key, iv);
+ return cipher;
+ } catch (NoSuchAlgorithmException | NoSuchPaddingException | java.security.InvalidKeyException |
+ InvalidAlgorithmParameterException e)
+ {
+ throw new AssertionError(e);
+ }
+ }
+
+ public static interface DecryptionCallback {
+ public void handlePlaintext(byte[] plaintext);
+ }
+
+ private static class NullDecryptionCallback implements DecryptionCallback {
+ @Override
+ public void handlePlaintext(byte[] plaintext) {}
+ }
+} \ No newline at end of file
diff --git a/src/main/java/org/whispersystems/libaxolotl/StaleKeyExchangeException.java b/src/main/java/org/whispersystems/libaxolotl/StaleKeyExchangeException.java
new file mode 100644
index 00000000..f94a3008
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/StaleKeyExchangeException.java
@@ -0,0 +1,4 @@
+package org.whispersystems.libaxolotl;
+
+public class StaleKeyExchangeException extends Throwable {
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/UntrustedIdentityException.java b/src/main/java/org/whispersystems/libaxolotl/UntrustedIdentityException.java
new file mode 100644
index 00000000..f434b923
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/UntrustedIdentityException.java
@@ -0,0 +1,4 @@
+package org.whispersystems.libaxolotl;
+
+public class UntrustedIdentityException extends Exception {
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/ecc/Curve.java b/src/main/java/org/whispersystems/libaxolotl/ecc/Curve.java
new file mode 100644
index 00000000..66b8cc3a
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/ecc/Curve.java
@@ -0,0 +1,78 @@
+/**
+ * Copyright (C) 2013 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl.ecc;
+
+import org.whispersystems.libaxolotl.InvalidKeyException;
+
+public class Curve {
+
+ public static final int DJB_TYPE = 0x05;
+
+ public static ECKeyPair generateKeyPair() {
+ return Curve25519.generateKeyPair();
+ }
+
+ public static ECPublicKey decodePoint(byte[] bytes, int offset)
+ throws InvalidKeyException
+ {
+ int type = bytes[offset];
+
+ if (type == DJB_TYPE) {
+ return Curve25519.decodePoint(bytes, offset);
+ } else {
+ throw new InvalidKeyException("Unknown key type: " + type);
+ }
+ }
+
+ public static ECPrivateKey decodePrivatePoint(byte[] bytes) {
+ return new DjbECPrivateKey(bytes);
+ }
+
+ public static byte[] calculateAgreement(ECPublicKey publicKey, ECPrivateKey privateKey)
+ throws InvalidKeyException
+ {
+ if (publicKey.getType() != privateKey.getType()) {
+ throw new InvalidKeyException("Public and private keys must be of the same type!");
+ }
+
+ if (publicKey.getType() == DJB_TYPE) {
+ return Curve25519.calculateAgreement(publicKey, privateKey);
+ } else {
+ throw new InvalidKeyException("Unknown type: " + publicKey.getType());
+ }
+ }
+
+ public static boolean verifySignature(ECPublicKey signingKey, byte[] message, byte[] signature)
+ throws InvalidKeyException
+ {
+ if (signingKey.getType() == DJB_TYPE) {
+ return Curve25519.verifySignature(signingKey, message, signature);
+ } else {
+ throw new InvalidKeyException("Unknown type: " + signingKey.getType());
+ }
+ }
+
+ public static byte[] calculateSignature(ECPrivateKey signingKey, byte[] message)
+ throws InvalidKeyException
+ {
+ if (signingKey.getType() == DJB_TYPE) {
+ return Curve25519.calculateSignature(signingKey, message);
+ } else {
+ throw new InvalidKeyException("Unknown type: " + signingKey.getType());
+ }
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/ecc/Curve25519.java b/src/main/java/org/whispersystems/libaxolotl/ecc/Curve25519.java
new file mode 100644
index 00000000..685a4a11
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/ecc/Curve25519.java
@@ -0,0 +1,98 @@
+/**
+ * Copyright (C) 2013 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl.ecc;
+
+import org.whispersystems.libaxolotl.InvalidKeyException;
+
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+
+public class Curve25519 {
+
+ static {
+ System.loadLibrary("curve25519");
+
+ try {
+ random = SecureRandom.getInstance("SHA1PRNG");
+ } catch (NoSuchAlgorithmException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ private static final SecureRandom random;
+
+ private static native byte[] calculateAgreement(byte[] ourPrivate, byte[] theirPublic);
+ private static native byte[] generatePublicKey(byte[] privateKey);
+ private static native byte[] generatePrivateKey(byte[] random);
+
+ private static native byte[] calculateSignature(byte[] random, byte[] privateKey, byte[] message);
+ private static native boolean verifySignature(byte[] publicKey, byte[] message, byte[] signature);
+
+ public static ECKeyPair generateKeyPair() {
+ byte[] privateKey = generatePrivateKey();
+ byte[] publicKey = generatePublicKey(privateKey);
+
+ return new ECKeyPair(new DjbECPublicKey(publicKey), new DjbECPrivateKey(privateKey));
+ }
+
+ static byte[] calculateAgreement(ECPublicKey publicKey, ECPrivateKey privateKey) {
+ return calculateAgreement(((DjbECPrivateKey)privateKey).getPrivateKey(),
+ ((DjbECPublicKey)publicKey).getPublicKey());
+ }
+
+ static byte[] calculateSignature(ECPrivateKey privateKey, byte[] message) {
+ byte[] random = getRandom(64);
+ return calculateSignature(random, ((DjbECPrivateKey)privateKey).getPrivateKey(), message);
+ }
+
+ static boolean verifySignature(ECPublicKey publicKey, byte[] message, byte[] signature) {
+ return verifySignature(((DjbECPublicKey)publicKey).getPublicKey(), message, signature);
+ }
+
+ static ECPublicKey decodePoint(byte[] encoded, int offset)
+ throws InvalidKeyException
+ {
+ int type = encoded[offset] & 0xFF;
+ byte[] keyBytes = new byte[32];
+ System.arraycopy(encoded, offset+1, keyBytes, 0, keyBytes.length);
+
+ if (type != Curve.DJB_TYPE) {
+ throw new InvalidKeyException("Bad key type: " + type);
+ }
+
+ return new DjbECPublicKey(keyBytes);
+ }
+
+ private static byte[] generatePrivateKey() {
+ byte[] privateKey = new byte[32];
+ random.nextBytes(privateKey);
+
+ return generatePrivateKey(privateKey);
+ }
+
+ private static byte[] getRandom(int size) {
+ try {
+ byte[] random = new byte[size];
+ SecureRandom.getInstance("SHA1PRNG").nextBytes(random);
+
+ return random;
+ } catch (NoSuchAlgorithmException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/ecc/DjbECPrivateKey.java b/src/main/java/org/whispersystems/libaxolotl/ecc/DjbECPrivateKey.java
new file mode 100644
index 00000000..ecb55b4e
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/ecc/DjbECPrivateKey.java
@@ -0,0 +1,41 @@
+/**
+ * Copyright (C) 2013 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.whispersystems.libaxolotl.ecc;
+
+public class DjbECPrivateKey implements ECPrivateKey {
+
+ private final byte[] privateKey;
+
+ DjbECPrivateKey(byte[] privateKey) {
+ this.privateKey = privateKey;
+ }
+
+ @Override
+ public byte[] serialize() {
+ return privateKey;
+ }
+
+ @Override
+ public int getType() {
+ return Curve.DJB_TYPE;
+ }
+
+ public byte[] getPrivateKey() {
+ return privateKey;
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/ecc/DjbECPublicKey.java b/src/main/java/org/whispersystems/libaxolotl/ecc/DjbECPublicKey.java
new file mode 100644
index 00000000..9f66d439
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/ecc/DjbECPublicKey.java
@@ -0,0 +1,66 @@
+/**
+ * Copyright (C) 2013 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.whispersystems.libaxolotl.ecc;
+
+import org.whispersystems.libaxolotl.util.ByteUtil;
+
+import java.math.BigInteger;
+import java.util.Arrays;
+
+public class DjbECPublicKey implements ECPublicKey {
+
+ private final byte[] publicKey;
+
+ DjbECPublicKey(byte[] publicKey) {
+ this.publicKey = publicKey;
+ }
+
+ @Override
+ public byte[] serialize() {
+ byte[] type = {Curve.DJB_TYPE};
+ return ByteUtil.combine(type, publicKey);
+ }
+
+ @Override
+ public int getType() {
+ return Curve.DJB_TYPE;
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (other == null) return false;
+ if (!(other instanceof DjbECPublicKey)) return false;
+
+ DjbECPublicKey that = (DjbECPublicKey)other;
+ return Arrays.equals(this.publicKey, that.publicKey);
+ }
+
+ @Override
+ public int hashCode() {
+ return Arrays.hashCode(publicKey);
+ }
+
+ @Override
+ public int compareTo(ECPublicKey another) {
+ return new BigInteger(publicKey).compareTo(new BigInteger(((DjbECPublicKey)another).publicKey));
+ }
+
+ public byte[] getPublicKey() {
+ return publicKey;
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/ecc/ECKeyPair.java b/src/main/java/org/whispersystems/libaxolotl/ecc/ECKeyPair.java
new file mode 100644
index 00000000..bcaec927
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/ecc/ECKeyPair.java
@@ -0,0 +1,37 @@
+/**
+ * Copyright (C) 2013 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.whispersystems.libaxolotl.ecc;
+
+public class ECKeyPair {
+
+ private final ECPublicKey publicKey;
+ private final ECPrivateKey privateKey;
+
+ public ECKeyPair(ECPublicKey publicKey, ECPrivateKey privateKey) {
+ this.publicKey = publicKey;
+ this.privateKey = privateKey;
+ }
+
+ public ECPublicKey getPublicKey() {
+ return publicKey;
+ }
+
+ public ECPrivateKey getPrivateKey() {
+ return privateKey;
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/ecc/ECPrivateKey.java b/src/main/java/org/whispersystems/libaxolotl/ecc/ECPrivateKey.java
new file mode 100644
index 00000000..922057de
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/ecc/ECPrivateKey.java
@@ -0,0 +1,23 @@
+/**
+ * Copyright (C) 2013 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.whispersystems.libaxolotl.ecc;
+
+public interface ECPrivateKey {
+ public byte[] serialize();
+ public int getType();
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/ecc/ECPublicKey.java b/src/main/java/org/whispersystems/libaxolotl/ecc/ECPublicKey.java
new file mode 100644
index 00000000..12576807
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/ecc/ECPublicKey.java
@@ -0,0 +1,27 @@
+/**
+ * Copyright (C) 2013 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.whispersystems.libaxolotl.ecc;
+
+public interface ECPublicKey extends Comparable<ECPublicKey> {
+
+ public static final int KEY_SIZE = 33;
+
+ public byte[] serialize();
+
+ public int getType();
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/groups/GroupCipher.java b/src/main/java/org/whispersystems/libaxolotl/groups/GroupCipher.java
new file mode 100644
index 00000000..43dac752
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/groups/GroupCipher.java
@@ -0,0 +1,146 @@
+package org.whispersystems.libaxolotl.groups;
+
+import org.whispersystems.libaxolotl.DuplicateMessageException;
+import org.whispersystems.libaxolotl.InvalidKeyIdException;
+import org.whispersystems.libaxolotl.InvalidMessageException;
+import org.whispersystems.libaxolotl.LegacyMessageException;
+import org.whispersystems.libaxolotl.NoSessionException;
+import org.whispersystems.libaxolotl.groups.ratchet.SenderChainKey;
+import org.whispersystems.libaxolotl.groups.ratchet.SenderMessageKey;
+import org.whispersystems.libaxolotl.groups.state.SenderKeyRecord;
+import org.whispersystems.libaxolotl.groups.state.SenderKeyState;
+import org.whispersystems.libaxolotl.groups.state.SenderKeyStore;
+import org.whispersystems.libaxolotl.protocol.SenderKeyMessage;
+
+import java.security.InvalidAlgorithmParameterException;
+import java.security.NoSuchAlgorithmException;
+
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+
+public class GroupCipher {
+
+ static final Object LOCK = new Object();
+
+ private final SenderKeyStore senderKeyStore;
+ private final String senderKeyId;
+
+ public GroupCipher(SenderKeyStore senderKeyStore, String senderKeyId) {
+ this.senderKeyStore = senderKeyStore;
+ this.senderKeyId = senderKeyId;
+ }
+
+ public byte[] encrypt(byte[] paddedPlaintext) throws NoSessionException {
+ synchronized (LOCK) {
+ try {
+ SenderKeyRecord record = senderKeyStore.loadSenderKey(senderKeyId);
+ SenderKeyState senderKeyState = record.getSenderKeyState();
+ SenderMessageKey senderKey = senderKeyState.getSenderChainKey().getSenderMessageKey();
+ byte[] ciphertext = getCipherText(senderKey.getIv(), senderKey.getCipherKey(), paddedPlaintext);
+
+ SenderKeyMessage senderKeyMessage = new SenderKeyMessage(senderKeyState.getKeyId(),
+ senderKey.getIteration(),
+ ciphertext,
+ senderKeyState.getSigningKeyPrivate());
+
+ senderKeyState.setSenderChainKey(senderKeyState.getSenderChainKey().getNext());
+
+ senderKeyStore.storeSenderKey(senderKeyId, record);
+
+ return senderKeyMessage.serialize();
+ } catch (InvalidKeyIdException e) {
+ throw new NoSessionException(e);
+ }
+ }
+ }
+
+ public byte[] decrypt(byte[] senderKeyMessageBytes)
+ throws LegacyMessageException, InvalidMessageException, DuplicateMessageException
+ {
+ synchronized (LOCK) {
+ try {
+ SenderKeyRecord record = senderKeyStore.loadSenderKey(senderKeyId);
+ SenderKeyMessage senderKeyMessage = new SenderKeyMessage(senderKeyMessageBytes);
+ SenderKeyState senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
+
+ senderKeyMessage.verifySignature(senderKeyState.getSigningKeyPublic());
+
+ SenderMessageKey senderKey = getSenderKey(senderKeyState, senderKeyMessage.getIteration());
+
+ byte[] plaintext = getPlainText(senderKey.getIv(), senderKey.getCipherKey(), senderKeyMessage.getCipherText());
+
+ senderKeyStore.storeSenderKey(senderKeyId, record);
+
+ return plaintext;
+ } catch (org.whispersystems.libaxolotl.InvalidKeyException | InvalidKeyIdException e) {
+ throw new InvalidMessageException(e);
+ }
+ }
+ }
+
+ private SenderMessageKey getSenderKey(SenderKeyState senderKeyState, int iteration)
+ throws DuplicateMessageException, InvalidMessageException
+ {
+ SenderChainKey senderChainKey = senderKeyState.getSenderChainKey();
+
+ if (senderChainKey.getIteration() > iteration) {
+ if (senderKeyState.hasSenderMessageKey(iteration)) {
+ return senderKeyState.removeSenderMessageKey(iteration);
+ } else {
+ throw new DuplicateMessageException("Received message with old counter: " +
+ senderChainKey.getIteration() + " , " + iteration);
+ }
+ }
+
+ if (senderChainKey.getIteration() - iteration > 2000) {
+ throw new InvalidMessageException("Over 2000 messages into the future!");
+ }
+
+ while (senderChainKey.getIteration() < iteration) {
+ senderKeyState.addSenderMessageKey(senderChainKey.getSenderMessageKey());
+ senderChainKey = senderChainKey.getNext();
+ }
+
+ senderKeyState.setSenderChainKey(senderChainKey.getNext());
+ return senderChainKey.getSenderMessageKey();
+ }
+
+ private byte[] getPlainText(byte[] iv, byte[] key, byte[] ciphertext)
+ throws InvalidMessageException
+ {
+ try {
+ IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);
+ Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
+
+ cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key, "AES"), ivParameterSpec);
+
+ return cipher.doFinal(ciphertext);
+ } catch (NoSuchAlgorithmException | NoSuchPaddingException | java.security.InvalidKeyException |
+ InvalidAlgorithmParameterException e)
+ {
+ throw new AssertionError(e);
+ } catch (IllegalBlockSizeException | BadPaddingException e) {
+ throw new InvalidMessageException(e);
+ }
+ }
+
+ private byte[] getCipherText(byte[] iv, byte[] key, byte[] plaintext) {
+ try {
+ IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);
+ Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
+
+ cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key, "AES"), ivParameterSpec);
+
+ return cipher.doFinal(plaintext);
+ } catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidAlgorithmParameterException |
+ IllegalBlockSizeException | BadPaddingException | java.security.InvalidKeyException e)
+ {
+ throw new AssertionError(e);
+ }
+ }
+
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/groups/GroupSessionBuilder.java b/src/main/java/org/whispersystems/libaxolotl/groups/GroupSessionBuilder.java
new file mode 100644
index 00000000..8b73484b
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/groups/GroupSessionBuilder.java
@@ -0,0 +1,38 @@
+package org.whispersystems.libaxolotl.groups;
+
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.groups.state.SenderKeyRecord;
+import org.whispersystems.libaxolotl.groups.state.SenderKeyStore;
+import org.whispersystems.libaxolotl.protocol.SenderKeyDistributionMessage;
+
+public class GroupSessionBuilder {
+
+ private final SenderKeyStore senderKeyStore;
+
+ public GroupSessionBuilder(SenderKeyStore senderKeyStore) {
+ this.senderKeyStore = senderKeyStore;
+ }
+
+ public void process(String sender, SenderKeyDistributionMessage senderKeyDistributionMessage) {
+ synchronized (GroupCipher.LOCK) {
+ SenderKeyRecord senderKeyRecord = senderKeyStore.loadSenderKey(sender);
+ senderKeyRecord.addSenderKeyState(senderKeyDistributionMessage.getId(),
+ senderKeyDistributionMessage.getIteration(),
+ senderKeyDistributionMessage.getChainKey(),
+ senderKeyDistributionMessage.getSignatureKey());
+ senderKeyStore.storeSenderKey(sender, senderKeyRecord);
+ }
+ }
+
+ public SenderKeyDistributionMessage process(String groupId, int keyId, int iteration,
+ byte[] chainKey, ECKeyPair signatureKey)
+ {
+ synchronized (GroupCipher.LOCK) {
+ SenderKeyRecord senderKeyRecord = senderKeyStore.loadSenderKey(groupId);
+ senderKeyRecord.setSenderKeyState(keyId, iteration, chainKey, signatureKey);
+ senderKeyStore.storeSenderKey(groupId, senderKeyRecord);
+
+ return new SenderKeyDistributionMessage(keyId, iteration, chainKey, signatureKey.getPublicKey());
+ }
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/groups/ratchet/SenderChainKey.java b/src/main/java/org/whispersystems/libaxolotl/groups/ratchet/SenderChainKey.java
new file mode 100644
index 00000000..71375923
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/groups/ratchet/SenderChainKey.java
@@ -0,0 +1,49 @@
+package org.whispersystems.libaxolotl.groups.ratchet;
+
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+
+public class SenderChainKey {
+
+ private static final byte[] MESSAGE_KEY_SEED = {0x01};
+ private static final byte[] CHAIN_KEY_SEED = {0x02};
+
+ private final int iteration;
+ private final byte[] chainKey;
+
+ public SenderChainKey(int iteration, byte[] chainKey) {
+ this.iteration = iteration;
+ this.chainKey = chainKey;
+ }
+
+ public int getIteration() {
+ return iteration;
+ }
+
+ public SenderMessageKey getSenderMessageKey() {
+ return new SenderMessageKey(iteration, getDerivative(MESSAGE_KEY_SEED, chainKey));
+ }
+
+ public SenderChainKey getNext() {
+ return new SenderChainKey(iteration + 1, getDerivative(CHAIN_KEY_SEED, chainKey));
+ }
+
+ public byte[] getSeed() {
+ return chainKey;
+ }
+
+ private byte[] getDerivative(byte[] seed, byte[] key) {
+ try {
+ Mac mac = Mac.getInstance("HmacSHA256");
+ mac.init(new SecretKeySpec(key, "HmacSHA256"));
+
+ return mac.doFinal(seed);
+ } catch (NoSuchAlgorithmException | InvalidKeyException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/groups/ratchet/SenderMessageKey.java b/src/main/java/org/whispersystems/libaxolotl/groups/ratchet/SenderMessageKey.java
new file mode 100644
index 00000000..8808a8e8
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/groups/ratchet/SenderMessageKey.java
@@ -0,0 +1,38 @@
+package org.whispersystems.libaxolotl.groups.ratchet;
+
+import org.whispersystems.libaxolotl.kdf.HKDFv3;
+import org.whispersystems.libaxolotl.util.ByteUtil;
+
+public class SenderMessageKey {
+
+ private final int iteration;
+ private final byte[] iv;
+ private final byte[] cipherKey;
+ private final byte[] seed;
+
+ public SenderMessageKey(int iteration, byte[] seed) {
+ byte[] derivative = new HKDFv3().deriveSecrets(seed, "WhisperGroup".getBytes(), 48);
+ byte[][] parts = ByteUtil.split(derivative, 16, 32);
+
+ this.iteration = iteration;
+ this.seed = seed;
+ this.iv = parts[0];
+ this.cipherKey = parts[1];
+ }
+
+ public int getIteration() {
+ return iteration;
+ }
+
+ public byte[] getIv() {
+ return iv;
+ }
+
+ public byte[] getCipherKey() {
+ return cipherKey;
+ }
+
+ public byte[] getSeed() {
+ return seed;
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/groups/state/SenderKeyRecord.java b/src/main/java/org/whispersystems/libaxolotl/groups/state/SenderKeyRecord.java
new file mode 100644
index 00000000..bb1ba952
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/groups/state/SenderKeyRecord.java
@@ -0,0 +1,64 @@
+package org.whispersystems.libaxolotl.groups.state;
+
+import org.whispersystems.libaxolotl.InvalidKeyIdException;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+import org.whispersystems.libaxolotl.state.StorageProtos;
+
+import java.io.IOException;
+import java.util.LinkedList;
+import java.util.List;
+
+import static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure;
+
+public class SenderKeyRecord {
+
+ private List<SenderKeyState> senderKeyStates = new LinkedList<>();
+
+ public SenderKeyRecord() {}
+
+ public SenderKeyRecord(byte[] serialized) throws IOException {
+ SenderKeyRecordStructure senderKeyRecordStructure = SenderKeyRecordStructure.parseFrom(serialized);
+
+ for (StorageProtos.SenderKeyStateStructure structure : senderKeyRecordStructure.getSenderKeyStatesList()) {
+ this.senderKeyStates.add(new SenderKeyState(structure));
+ }
+ }
+
+ public SenderKeyState getSenderKeyState() throws InvalidKeyIdException {
+ if (!senderKeyStates.isEmpty()) {
+ return senderKeyStates.get(0);
+ } else {
+ throw new InvalidKeyIdException("No key state in record!");
+ }
+ }
+
+ public SenderKeyState getSenderKeyState(int keyId) throws InvalidKeyIdException {
+ for (SenderKeyState state : senderKeyStates) {
+ if (state.getKeyId() == keyId) {
+ return state;
+ }
+ }
+
+ throw new InvalidKeyIdException("No keys for: " + keyId);
+ }
+
+ public void addSenderKeyState(int id, int iteration, byte[] chainKey, ECPublicKey signatureKey) {
+ senderKeyStates.add(new SenderKeyState(id, iteration, chainKey, signatureKey));
+ }
+
+ public void setSenderKeyState(int id, int iteration, byte[] chainKey, ECKeyPair signatureKey) {
+ senderKeyStates.clear();
+ senderKeyStates.add(new SenderKeyState(id, iteration, chainKey, signatureKey));
+ }
+
+ public byte[] serialize() {
+ SenderKeyRecordStructure.Builder recordStructure = SenderKeyRecordStructure.newBuilder();
+
+ for (SenderKeyState senderKeyState : senderKeyStates) {
+ recordStructure.addSenderKeyStates(senderKeyState.getStructure());
+ }
+
+ return recordStructure.build().toByteArray();
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/groups/state/SenderKeyState.java b/src/main/java/org/whispersystems/libaxolotl/groups/state/SenderKeyState.java
new file mode 100644
index 00000000..80498ce0
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/groups/state/SenderKeyState.java
@@ -0,0 +1,144 @@
+package org.whispersystems.libaxolotl.groups.state;
+
+import com.google.protobuf.ByteString;
+
+import org.whispersystems.libaxolotl.InvalidKeyException;
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.ecc.ECPrivateKey;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+import org.whispersystems.libaxolotl.groups.ratchet.SenderChainKey;
+import org.whispersystems.libaxolotl.groups.ratchet.SenderMessageKey;
+import org.whispersystems.libaxolotl.util.guava.Optional;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure;
+
+public class SenderKeyState {
+
+ private SenderKeyStateStructure senderKeyStateStructure;
+
+ public SenderKeyState(int id, int iteration, byte[] chainKey, ECPublicKey signatureKey) {
+ this(id, iteration, chainKey, signatureKey, Optional.<ECPrivateKey>absent());
+ }
+
+ public SenderKeyState(int id, int iteration, byte[] chainKey, ECKeyPair signatureKey) {
+ this(id, iteration, chainKey, signatureKey.getPublicKey(), Optional.of(signatureKey.getPrivateKey()));
+ }
+
+ private SenderKeyState(int id, int iteration, byte[] chainKey,
+ ECPublicKey signatureKeyPublic,
+ Optional<ECPrivateKey> signatureKeyPrivate)
+ {
+ SenderKeyStateStructure.SenderChainKey senderChainKeyStructure =
+ SenderKeyStateStructure.SenderChainKey.newBuilder()
+ .setIteration(iteration)
+ .setSeed(ByteString.copyFrom(chainKey))
+ .build();
+
+ SenderKeyStateStructure.SenderSigningKey.Builder signingKeyStructure =
+ SenderKeyStateStructure.SenderSigningKey.newBuilder()
+ .setPublic(ByteString.copyFrom(signatureKeyPublic.serialize()));
+
+ if (signatureKeyPrivate.isPresent()) {
+ signingKeyStructure.setPrivate(ByteString.copyFrom(signatureKeyPrivate.get().serialize()));
+ }
+
+ this.senderKeyStateStructure = SenderKeyStateStructure.newBuilder()
+ .setSenderKeyId(id)
+ .setSenderChainKey(senderChainKeyStructure)
+ .setSenderSigningKey(signingKeyStructure)
+ .build();
+ }
+
+ public SenderKeyState(SenderKeyStateStructure senderKeyStateStructure) {
+ this.senderKeyStateStructure = senderKeyStateStructure;
+ }
+
+ public int getKeyId() {
+ return senderKeyStateStructure.getSenderKeyId();
+ }
+
+ public SenderChainKey getSenderChainKey() {
+ return new SenderChainKey(senderKeyStateStructure.getSenderChainKey().getIteration(),
+ senderKeyStateStructure.getSenderChainKey().getSeed().toByteArray());
+ }
+
+ public void setSenderChainKey(SenderChainKey chainKey) {
+ SenderKeyStateStructure.SenderChainKey senderChainKeyStructure =
+ SenderKeyStateStructure.SenderChainKey.newBuilder()
+ .setIteration(chainKey.getIteration())
+ .setSeed(ByteString.copyFrom(chainKey.getSeed()))
+ .build();
+
+ this.senderKeyStateStructure = senderKeyStateStructure.toBuilder()
+ .setSenderChainKey(senderChainKeyStructure)
+ .build();
+ }
+
+ public ECPublicKey getSigningKeyPublic() throws InvalidKeyException {
+ return Curve.decodePoint(senderKeyStateStructure.getSenderSigningKey()
+ .getPublic()
+ .toByteArray(), 0);
+ }
+
+ public ECPrivateKey getSigningKeyPrivate() {
+ return Curve.decodePrivatePoint(senderKeyStateStructure.getSenderSigningKey()
+ .getPrivate().toByteArray());
+ }
+
+ public boolean hasSenderMessageKey(int iteration) {
+ for (SenderKeyStateStructure.SenderMessageKey senderMessageKey : senderKeyStateStructure.getSenderMessageKeysList()) {
+ if (senderMessageKey.getIteration() == iteration) return true;
+ }
+
+ return false;
+ }
+
+ public void addSenderMessageKey(SenderMessageKey senderMessageKey) {
+ SenderKeyStateStructure.SenderMessageKey senderMessageKeyStructure =
+ SenderKeyStateStructure.SenderMessageKey.newBuilder()
+ .setIteration(senderMessageKey.getIteration())
+ .setSeed(ByteString.copyFrom(senderMessageKey.getSeed()))
+ .build();
+
+ this.senderKeyStateStructure = this.senderKeyStateStructure.toBuilder()
+ .addSenderMessageKeys(senderMessageKeyStructure)
+ .build();
+ }
+
+ public SenderMessageKey removeSenderMessageKey(int iteration) {
+ List<SenderKeyStateStructure.SenderMessageKey> keys = new LinkedList<>(senderKeyStateStructure.getSenderMessageKeysList());
+ Iterator<SenderKeyStateStructure.SenderMessageKey> iterator = keys.iterator();
+
+ SenderKeyStateStructure.SenderMessageKey result = null;
+
+ while (iterator.hasNext()) {
+ SenderKeyStateStructure.SenderMessageKey senderMessageKey = iterator.next();
+
+ if (senderMessageKey.getIteration() == iteration) {
+ result = senderMessageKey;
+ iterator.remove();
+ break;
+ }
+ }
+
+ this.senderKeyStateStructure = this.senderKeyStateStructure.toBuilder()
+ .clearSenderMessageKeys()
+ .addAllSenderMessageKeys(keys)
+ .build();
+
+ if (result != null) {
+ return new SenderMessageKey(result.getIteration(), result.getSeed().toByteArray());
+ } else {
+ return null;
+ }
+ }
+
+ public SenderKeyStateStructure getStructure() {
+ return senderKeyStateStructure;
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/groups/state/SenderKeyStore.java b/src/main/java/org/whispersystems/libaxolotl/groups/state/SenderKeyStore.java
new file mode 100644
index 00000000..da01b1f3
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/groups/state/SenderKeyStore.java
@@ -0,0 +1,6 @@
+package org.whispersystems.libaxolotl.groups.state;
+
+public interface SenderKeyStore {
+ public void storeSenderKey(String senderKeyId, SenderKeyRecord record);
+ public SenderKeyRecord loadSenderKey(String senderKeyId);
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/kdf/DerivedMessageSecrets.java b/src/main/java/org/whispersystems/libaxolotl/kdf/DerivedMessageSecrets.java
new file mode 100644
index 00000000..b3f54fb8
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/kdf/DerivedMessageSecrets.java
@@ -0,0 +1,61 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.whispersystems.libaxolotl.kdf;
+
+import org.whispersystems.libaxolotl.util.ByteUtil;
+
+import java.text.ParseException;
+
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+
+public class DerivedMessageSecrets {
+
+ public static final int SIZE = 80;
+ private static final int CIPHER_KEY_LENGTH = 32;
+ private static final int MAC_KEY_LENGTH = 32;
+ private static final int IV_LENGTH = 16;
+
+ private final SecretKeySpec cipherKey;
+ private final SecretKeySpec macKey;
+ private final IvParameterSpec iv;
+
+ public DerivedMessageSecrets(byte[] okm) {
+ try {
+ byte[][] keys = ByteUtil.split(okm, CIPHER_KEY_LENGTH, MAC_KEY_LENGTH, IV_LENGTH);
+
+ this.cipherKey = new SecretKeySpec(keys[0], "AES");
+ this.macKey = new SecretKeySpec(keys[1], "HmacSHA256");
+ this.iv = new IvParameterSpec(keys[2]);
+ } catch (ParseException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ public SecretKeySpec getCipherKey() {
+ return cipherKey;
+ }
+
+ public SecretKeySpec getMacKey() {
+ return macKey;
+ }
+
+ public IvParameterSpec getIv() {
+ return iv;
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/kdf/DerivedRootSecrets.java b/src/main/java/org/whispersystems/libaxolotl/kdf/DerivedRootSecrets.java
new file mode 100644
index 00000000..82cc541d
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/kdf/DerivedRootSecrets.java
@@ -0,0 +1,26 @@
+package org.whispersystems.libaxolotl.kdf;
+
+import org.whispersystems.libaxolotl.util.ByteUtil;
+
+public class DerivedRootSecrets {
+
+ public static final int SIZE = 64;
+
+ private final byte[] rootKey;
+ private final byte[] chainKey;
+
+ public DerivedRootSecrets(byte[] okm) {
+ byte[][] keys = ByteUtil.split(okm, 32, 32);
+ this.rootKey = keys[0];
+ this.chainKey = keys[1];
+ }
+
+ public byte[] getRootKey() {
+ return rootKey;
+ }
+
+ public byte[] getChainKey() {
+ return chainKey;
+ }
+
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/kdf/HKDF.java b/src/main/java/org/whispersystems/libaxolotl/kdf/HKDF.java
new file mode 100644
index 00000000..d190822d
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/kdf/HKDF.java
@@ -0,0 +1,93 @@
+/**
+ * Copyright (C) 2013 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.whispersystems.libaxolotl.kdf;
+
+import java.io.ByteArrayOutputStream;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+
+public abstract class HKDF {
+
+ private static final int HASH_OUTPUT_SIZE = 32;
+
+ public static HKDF createFor(int messageVersion) {
+ switch (messageVersion) {
+ case 2: return new HKDFv2();
+ case 3: return new HKDFv3();
+ default: throw new AssertionError("Unknown version: " + messageVersion);
+ }
+ }
+
+ public byte[] deriveSecrets(byte[] inputKeyMaterial, byte[] info, int outputLength) {
+ byte[] salt = new byte[HASH_OUTPUT_SIZE];
+ return deriveSecrets(inputKeyMaterial, salt, info, outputLength);
+ }
+
+ public byte[] deriveSecrets(byte[] inputKeyMaterial, byte[] salt, byte[] info, int outputLength) {
+ byte[] prk = extract(salt, inputKeyMaterial);
+ return expand(prk, info, outputLength);
+ }
+
+ private byte[] extract(byte[] salt, byte[] inputKeyMaterial) {
+ try {
+ Mac mac = Mac.getInstance("HmacSHA256");
+ mac.init(new SecretKeySpec(salt, "HmacSHA256"));
+ return mac.doFinal(inputKeyMaterial);
+ } catch (NoSuchAlgorithmException | InvalidKeyException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ private byte[] expand(byte[] prk, byte[] info, int outputSize) {
+ try {
+ int iterations = (int) Math.ceil((double) outputSize / (double) HASH_OUTPUT_SIZE);
+ byte[] mixin = new byte[0];
+ ByteArrayOutputStream results = new ByteArrayOutputStream();
+ int remainingBytes = outputSize;
+
+ for (int i= getIterationStartOffset();i<iterations + getIterationStartOffset();i++) {
+ Mac mac = Mac.getInstance("HmacSHA256");
+ mac.init(new SecretKeySpec(prk, "HmacSHA256"));
+
+ mac.update(mixin);
+ if (info != null) {
+ mac.update(info);
+ }
+ mac.update((byte)i);
+
+ byte[] stepResult = mac.doFinal();
+ int stepSize = Math.min(remainingBytes, stepResult.length);
+
+ results.write(stepResult, 0, stepSize);
+
+ mixin = stepResult;
+ remainingBytes -= stepSize;
+ }
+
+ return results.toByteArray();
+ } catch (NoSuchAlgorithmException | InvalidKeyException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ protected abstract int getIterationStartOffset();
+
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/kdf/HKDFv2.java b/src/main/java/org/whispersystems/libaxolotl/kdf/HKDFv2.java
new file mode 100644
index 00000000..86e4bf5f
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/kdf/HKDFv2.java
@@ -0,0 +1,8 @@
+package org.whispersystems.libaxolotl.kdf;
+
+public class HKDFv2 extends HKDF {
+ @Override
+ protected int getIterationStartOffset() {
+ return 0;
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/kdf/HKDFv3.java b/src/main/java/org/whispersystems/libaxolotl/kdf/HKDFv3.java
new file mode 100644
index 00000000..a1934c90
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/kdf/HKDFv3.java
@@ -0,0 +1,8 @@
+package org.whispersystems.libaxolotl.kdf;
+
+public class HKDFv3 extends HKDF {
+ @Override
+ protected int getIterationStartOffset() {
+ return 1;
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/protocol/CiphertextMessage.java b/src/main/java/org/whispersystems/libaxolotl/protocol/CiphertextMessage.java
new file mode 100644
index 00000000..cf4be756
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/protocol/CiphertextMessage.java
@@ -0,0 +1,35 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl.protocol;
+
+public interface CiphertextMessage {
+
+ public static final int UNSUPPORTED_VERSION = 1;
+ public static final int CURRENT_VERSION = 3;
+
+ public static final int WHISPER_TYPE = 2;
+ public static final int PREKEY_TYPE = 3;
+ public static final int SENDERKEY_TYPE = 4;
+ public static final int SENDERKEY_DISTRIBUTION_TYPE = 5;
+
+ // This should be the worst case (worse than V2). So not always accurate, but good enough for padding.
+ public static final int ENCRYPTED_MESSAGE_OVERHEAD = 53;
+
+ public byte[] serialize();
+ public int getType();
+
+} \ No newline at end of file
diff --git a/src/main/java/org/whispersystems/libaxolotl/protocol/KeyExchangeMessage.java b/src/main/java/org/whispersystems/libaxolotl/protocol/KeyExchangeMessage.java
new file mode 100644
index 00000000..bec9208c
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/protocol/KeyExchangeMessage.java
@@ -0,0 +1,153 @@
+package org.whispersystems.libaxolotl.protocol;
+
+
+import com.google.protobuf.ByteString;
+
+import org.whispersystems.libaxolotl.IdentityKey;
+import org.whispersystems.libaxolotl.InvalidKeyException;
+import org.whispersystems.libaxolotl.InvalidMessageException;
+import org.whispersystems.libaxolotl.InvalidVersionException;
+import org.whispersystems.libaxolotl.LegacyMessageException;
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+import org.whispersystems.libaxolotl.util.ByteUtil;
+
+import java.io.IOException;
+
+import static org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage.Builder;
+
+public class KeyExchangeMessage {
+
+ public static final int INITIATE_FLAG = 0x01;
+ public static final int RESPONSE_FLAG = 0X02;
+ public static final int SIMULTAENOUS_INITIATE_FLAG = 0x04;
+
+ private final int version;
+ private final int supportedVersion;
+ private final int sequence;
+ private final int flags;
+
+ private final ECPublicKey baseKey;
+ private final byte[] baseKeySignature;
+ private final ECPublicKey ratchetKey;
+ private final IdentityKey identityKey;
+ private final byte[] serialized;
+
+ public KeyExchangeMessage(int messageVersion, int sequence, int flags,
+ ECPublicKey baseKey, byte[] baseKeySignature,
+ ECPublicKey ratchetKey,
+ IdentityKey identityKey)
+ {
+ this.supportedVersion = CiphertextMessage.CURRENT_VERSION;
+ this.version = messageVersion;
+ this.sequence = sequence;
+ this.flags = flags;
+ this.baseKey = baseKey;
+ this.baseKeySignature = baseKeySignature;
+ this.ratchetKey = ratchetKey;
+ this.identityKey = identityKey;
+
+ byte[] version = {ByteUtil.intsToByteHighAndLow(this.version, this.supportedVersion)};
+ Builder builder = WhisperProtos.KeyExchangeMessage
+ .newBuilder()
+ .setId((sequence << 5) | flags)
+ .setBaseKey(ByteString.copyFrom(baseKey.serialize()))
+ .setRatchetKey(ByteString.copyFrom(ratchetKey.serialize()))
+ .setIdentityKey(ByteString.copyFrom(identityKey.serialize()));
+
+ if (messageVersion >= 3) {
+ builder.setBaseKeySignature(ByteString.copyFrom(baseKeySignature));
+ }
+
+ this.serialized = ByteUtil.combine(version, builder.build().toByteArray());
+ }
+
+ public KeyExchangeMessage(byte[] serialized)
+ throws InvalidMessageException, InvalidVersionException, LegacyMessageException
+ {
+ try {
+ byte[][] parts = ByteUtil.split(serialized, 1, serialized.length - 1);
+ this.version = ByteUtil.highBitsToInt(parts[0][0]);
+ this.supportedVersion = ByteUtil.lowBitsToInt(parts[0][0]);
+
+ if (this.version <= CiphertextMessage.UNSUPPORTED_VERSION) {
+ throw new LegacyMessageException("Unsupported legacy version: " + this.version);
+ }
+
+ if (this.version > CiphertextMessage.CURRENT_VERSION) {
+ throw new InvalidVersionException("Unknown version: " + this.version);
+ }
+
+ WhisperProtos.KeyExchangeMessage message = WhisperProtos.KeyExchangeMessage.parseFrom(parts[1]);
+
+ if (!message.hasId() || !message.hasBaseKey() ||
+ !message.hasRatchetKey() || !message.hasIdentityKey() ||
+ (this.version >=3 && !message.hasBaseKeySignature()))
+ {
+ throw new InvalidMessageException("Some required fields missing!");
+ }
+
+ this.sequence = message.getId() >> 5;
+ this.flags = message.getId() & 0x1f;
+ this.serialized = serialized;
+ this.baseKey = Curve.decodePoint(message.getBaseKey().toByteArray(), 0);
+ this.baseKeySignature = message.getBaseKeySignature().toByteArray();
+ this.ratchetKey = Curve.decodePoint(message.getRatchetKey().toByteArray(), 0);
+ this.identityKey = new IdentityKey(message.getIdentityKey().toByteArray(), 0);
+ } catch (InvalidKeyException | IOException e) {
+ throw new InvalidMessageException(e);
+ }
+ }
+
+ public int getVersion() {
+ return version;
+ }
+
+ public ECPublicKey getBaseKey() {
+ return baseKey;
+ }
+
+ public byte[] getBaseKeySignature() {
+ return baseKeySignature;
+ }
+
+ public ECPublicKey getRatchetKey() {
+ return ratchetKey;
+ }
+
+ public IdentityKey getIdentityKey() {
+ return identityKey;
+ }
+
+ public boolean hasIdentityKey() {
+ return true;
+ }
+
+ public int getMaxVersion() {
+ return supportedVersion;
+ }
+
+ public boolean isResponse() {
+ return ((flags & RESPONSE_FLAG) != 0);
+ }
+
+ public boolean isInitiate() {
+ return (flags & INITIATE_FLAG) != 0;
+ }
+
+ public boolean isResponseForSimultaneousInitiate() {
+ return (flags & SIMULTAENOUS_INITIATE_FLAG) != 0;
+ }
+
+ public int getFlags() {
+ return flags;
+ }
+
+ public int getSequence() {
+ return sequence;
+ }
+
+ public byte[] serialize() {
+ return serialized;
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/protocol/PreKeyWhisperMessage.java b/src/main/java/org/whispersystems/libaxolotl/protocol/PreKeyWhisperMessage.java
new file mode 100644
index 00000000..fff6d02a
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/protocol/PreKeyWhisperMessage.java
@@ -0,0 +1,147 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl.protocol;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+
+import org.whispersystems.libaxolotl.IdentityKey;
+import org.whispersystems.libaxolotl.InvalidKeyException;
+import org.whispersystems.libaxolotl.InvalidMessageException;
+import org.whispersystems.libaxolotl.InvalidVersionException;
+import org.whispersystems.libaxolotl.LegacyMessageException;
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+import org.whispersystems.libaxolotl.util.ByteUtil;
+import org.whispersystems.libaxolotl.util.guava.Optional;
+
+
+public class PreKeyWhisperMessage implements CiphertextMessage {
+
+ private final int version;
+ private final int registrationId;
+ private final Optional<Integer> preKeyId;
+ private final int signedPreKeyId;
+ private final ECPublicKey baseKey;
+ private final IdentityKey identityKey;
+ private final WhisperMessage message;
+ private final byte[] serialized;
+
+ public PreKeyWhisperMessage(byte[] serialized)
+ throws InvalidMessageException, InvalidVersionException
+ {
+ try {
+ this.version = ByteUtil.highBitsToInt(serialized[0]);
+
+ if (this.version > CiphertextMessage.CURRENT_VERSION) {
+ throw new InvalidVersionException("Unknown version: " + this.version);
+ }
+
+ WhisperProtos.PreKeyWhisperMessage preKeyWhisperMessage
+ = WhisperProtos.PreKeyWhisperMessage.parseFrom(ByteString.copyFrom(serialized, 1,
+ serialized.length-1));
+
+ if ((version == 2 && !preKeyWhisperMessage.hasPreKeyId()) ||
+ (version == 3 && !preKeyWhisperMessage.hasSignedPreKeyId()) ||
+ !preKeyWhisperMessage.hasBaseKey() ||
+ !preKeyWhisperMessage.hasIdentityKey() ||
+ !preKeyWhisperMessage.hasMessage())
+ {
+ throw new InvalidMessageException("Incomplete message.");
+ }
+
+ this.serialized = serialized;
+ this.registrationId = preKeyWhisperMessage.getRegistrationId();
+ this.preKeyId = preKeyWhisperMessage.hasPreKeyId() ? Optional.of(preKeyWhisperMessage.getPreKeyId()) : Optional.<Integer>absent();
+ this.signedPreKeyId = preKeyWhisperMessage.hasSignedPreKeyId() ? preKeyWhisperMessage.getSignedPreKeyId() : -1;
+ this.baseKey = Curve.decodePoint(preKeyWhisperMessage.getBaseKey().toByteArray(), 0);
+ this.identityKey = new IdentityKey(Curve.decodePoint(preKeyWhisperMessage.getIdentityKey().toByteArray(), 0));
+ this.message = new WhisperMessage(preKeyWhisperMessage.getMessage().toByteArray());
+ } catch (InvalidProtocolBufferException | InvalidKeyException | LegacyMessageException e) {
+ throw new InvalidMessageException(e);
+ }
+ }
+
+ public PreKeyWhisperMessage(int messageVersion, int registrationId, Optional<Integer> preKeyId,
+ int signedPreKeyId, ECPublicKey baseKey, IdentityKey identityKey,
+ WhisperMessage message)
+ {
+ this.version = messageVersion;
+ this.registrationId = registrationId;
+ this.preKeyId = preKeyId;
+ this.signedPreKeyId = signedPreKeyId;
+ this.baseKey = baseKey;
+ this.identityKey = identityKey;
+ this.message = message;
+
+ WhisperProtos.PreKeyWhisperMessage.Builder builder =
+ WhisperProtos.PreKeyWhisperMessage.newBuilder()
+ .setSignedPreKeyId(signedPreKeyId)
+ .setBaseKey(ByteString.copyFrom(baseKey.serialize()))
+ .setIdentityKey(ByteString.copyFrom(identityKey.serialize()))
+ .setMessage(ByteString.copyFrom(message.serialize()))
+ .setRegistrationId(registrationId);
+
+ if (preKeyId.isPresent()) {
+ builder.setPreKeyId(preKeyId.get());
+ }
+
+ byte[] versionBytes = {ByteUtil.intsToByteHighAndLow(this.version, CURRENT_VERSION)};
+ byte[] messageBytes = builder.build().toByteArray();
+
+ this.serialized = ByteUtil.combine(versionBytes, messageBytes);
+ }
+
+ public int getMessageVersion() {
+ return version;
+ }
+
+ public IdentityKey getIdentityKey() {
+ return identityKey;
+ }
+
+ public int getRegistrationId() {
+ return registrationId;
+ }
+
+ public Optional<Integer> getPreKeyId() {
+ return preKeyId;
+ }
+
+ public int getSignedPreKeyId() {
+ return signedPreKeyId;
+ }
+
+ public ECPublicKey getBaseKey() {
+ return baseKey;
+ }
+
+ public WhisperMessage getWhisperMessage() {
+ return message;
+ }
+
+ @Override
+ public byte[] serialize() {
+ return serialized;
+ }
+
+ @Override
+ public int getType() {
+ return CiphertextMessage.PREKEY_TYPE;
+ }
+
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/protocol/SenderKeyDistributionMessage.java b/src/main/java/org/whispersystems/libaxolotl/protocol/SenderKeyDistributionMessage.java
new file mode 100644
index 00000000..424dd87c
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/protocol/SenderKeyDistributionMessage.java
@@ -0,0 +1,56 @@
+package org.whispersystems.libaxolotl.protocol;
+
+import com.google.protobuf.ByteString;
+
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+import org.whispersystems.libaxolotl.util.ByteUtil;
+
+public class SenderKeyDistributionMessage implements CiphertextMessage {
+
+ private final int id;
+ private final int iteration;
+ private final byte[] chainKey;
+ private final ECPublicKey signatureKey;
+ private final byte[] serialized;
+
+ public SenderKeyDistributionMessage(int id, int iteration, byte[] chainKey, ECPublicKey signatureKey) {
+ byte[] version = {ByteUtil.intsToByteHighAndLow(CURRENT_VERSION, CURRENT_VERSION)};
+
+ this.id = id;
+ this.iteration = iteration;
+ this.chainKey = chainKey;
+ this.signatureKey = signatureKey;
+ this.serialized = WhisperProtos.SenderKeyDistributionMessage.newBuilder()
+ .setId(id)
+ .setIteration(iteration)
+ .setChainKey(ByteString.copyFrom(chainKey))
+ .setSigningKey(ByteString.copyFrom(signatureKey.serialize()))
+ .build().toByteArray();
+ }
+
+ @Override
+ public byte[] serialize() {
+ return serialized;
+ }
+
+ @Override
+ public int getType() {
+ return SENDERKEY_DISTRIBUTION_TYPE;
+ }
+
+ public int getIteration() {
+ return iteration;
+ }
+
+ public byte[] getChainKey() {
+ return chainKey;
+ }
+
+ public ECPublicKey getSignatureKey() {
+ return signatureKey;
+ }
+
+ public int getId() {
+ return id;
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/protocol/SenderKeyMessage.java b/src/main/java/org/whispersystems/libaxolotl/protocol/SenderKeyMessage.java
new file mode 100644
index 00000000..b3a17456
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/protocol/SenderKeyMessage.java
@@ -0,0 +1,121 @@
+package org.whispersystems.libaxolotl.protocol;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+
+import org.whispersystems.libaxolotl.InvalidKeyException;
+import org.whispersystems.libaxolotl.InvalidMessageException;
+import org.whispersystems.libaxolotl.LegacyMessageException;
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECPrivateKey;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+import org.whispersystems.libaxolotl.util.ByteUtil;
+
+import java.text.ParseException;
+
+public class SenderKeyMessage implements CiphertextMessage {
+
+ private static final int SIGNATURE_LENGTH = 64;
+
+ private final int messageVersion;
+ private final int keyId;
+ private final int iteration;
+ private final byte[] ciphertext;
+ private final byte[] serialized;
+
+ public SenderKeyMessage(byte[] serialized) throws InvalidMessageException, LegacyMessageException {
+ try {
+ byte[][] messageParts = ByteUtil.split(serialized, 1, serialized.length - 1 - SIGNATURE_LENGTH, SIGNATURE_LENGTH);
+ byte version = messageParts[0][0];
+ byte[] message = messageParts[1];
+ byte[] signature = messageParts[2];
+
+ if (ByteUtil.highBitsToInt(version) < 3) {
+ throw new LegacyMessageException("Legacy message: " + ByteUtil.highBitsToInt(version));
+ }
+
+ if (ByteUtil.highBitsToInt(version) > CURRENT_VERSION) {
+ throw new InvalidMessageException("Unknown version: " + ByteUtil.highBitsToInt(version));
+ }
+
+ WhisperProtos.SenderKeyMessage senderKeyMessage = WhisperProtos.SenderKeyMessage.parseFrom(message);
+
+ if (!senderKeyMessage.hasId() ||
+ !senderKeyMessage.hasIteration() ||
+ !senderKeyMessage.hasCiphertext())
+ {
+ throw new InvalidMessageException("Incomplete message.");
+ }
+
+ this.serialized = serialized;
+ this.messageVersion = ByteUtil.highBitsToInt(version);
+ this.keyId = senderKeyMessage.getId();
+ this.iteration = senderKeyMessage.getIteration();
+ this.ciphertext = senderKeyMessage.getCiphertext().toByteArray();
+ } catch (InvalidProtocolBufferException | ParseException e) {
+ throw new InvalidMessageException(e);
+ }
+ }
+
+ public SenderKeyMessage(int keyId, int iteration, byte[] ciphertext, ECPrivateKey signatureKey) {
+ byte[] version = {ByteUtil.intsToByteHighAndLow(CURRENT_VERSION, CURRENT_VERSION)};
+ byte[] message = WhisperProtos.SenderKeyMessage.newBuilder()
+ .setId(keyId)
+ .setIteration(iteration)
+ .setCiphertext(ByteString.copyFrom(ciphertext))
+ .build().toByteArray();
+
+ byte[] signature = getSignature(signatureKey, ByteUtil.combine(version, message));
+
+ this.serialized = ByteUtil.combine(version, message, signature);
+ this.messageVersion = CURRENT_VERSION;
+ this.keyId = keyId;
+ this.iteration = iteration;
+ this.ciphertext = ciphertext;
+ }
+
+ public int getKeyId() {
+ return keyId;
+ }
+
+ public int getIteration() {
+ return iteration;
+ }
+
+ public byte[] getCipherText() {
+ return ciphertext;
+ }
+
+ public void verifySignature(ECPublicKey signatureKey)
+ throws InvalidMessageException
+ {
+ try {
+ byte[][] parts = ByteUtil.split(serialized, serialized.length - SIGNATURE_LENGTH, SIGNATURE_LENGTH);
+
+ if (!Curve.verifySignature(signatureKey, parts[0], parts[1])) {
+ throw new InvalidMessageException("Invalid signature!");
+ }
+
+ } catch (InvalidKeyException e) {
+ throw new InvalidMessageException(e);
+ }
+ }
+
+ private byte[] getSignature(ECPrivateKey signatureKey, byte[] serialized) {
+ try {
+ return Curve.calculateSignature(signatureKey, serialized);
+ } catch (InvalidKeyException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ @Override
+ public byte[] serialize() {
+ return serialized;
+ }
+
+ @Override
+ public int getType() {
+ return CiphertextMessage.SENDERKEY_TYPE;
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/protocol/WhisperMessage.java b/src/main/java/org/whispersystems/libaxolotl/protocol/WhisperMessage.java
new file mode 100644
index 00000000..980bec1f
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/protocol/WhisperMessage.java
@@ -0,0 +1,172 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl.protocol;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.InvalidProtocolBufferException;
+
+import org.whispersystems.libaxolotl.IdentityKey;
+import org.whispersystems.libaxolotl.InvalidKeyException;
+import org.whispersystems.libaxolotl.InvalidMessageException;
+import org.whispersystems.libaxolotl.LegacyMessageException;
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+import org.whispersystems.libaxolotl.util.ByteUtil;
+
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.text.ParseException;
+
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+
+public class WhisperMessage implements CiphertextMessage {
+
+ private static final int MAC_LENGTH = 8;
+
+ private final int messageVersion;
+ private final ECPublicKey senderRatchetKey;
+ private final int counter;
+ private final int previousCounter;
+ private final byte[] ciphertext;
+ private final byte[] serialized;
+
+ public WhisperMessage(byte[] serialized) throws InvalidMessageException, LegacyMessageException {
+ try {
+ byte[][] messageParts = ByteUtil.split(serialized, 1, serialized.length - 1 - MAC_LENGTH, MAC_LENGTH);
+ byte version = messageParts[0][0];
+ byte[] message = messageParts[1];
+ byte[] mac = messageParts[2];
+
+ if (ByteUtil.highBitsToInt(version) <= CiphertextMessage.UNSUPPORTED_VERSION) {
+ throw new LegacyMessageException("Legacy message: " + ByteUtil.highBitsToInt(version));
+ }
+
+ if (ByteUtil.highBitsToInt(version) > CURRENT_VERSION) {
+ throw new InvalidMessageException("Unknown version: " + ByteUtil.highBitsToInt(version));
+ }
+
+ WhisperProtos.WhisperMessage whisperMessage = WhisperProtos.WhisperMessage.parseFrom(message);
+
+ if (!whisperMessage.hasCiphertext() ||
+ !whisperMessage.hasCounter() ||
+ !whisperMessage.hasRatchetKey())
+ {
+ throw new InvalidMessageException("Incomplete message.");
+ }
+
+ this.serialized = serialized;
+ this.senderRatchetKey = Curve.decodePoint(whisperMessage.getRatchetKey().toByteArray(), 0);
+ this.messageVersion = ByteUtil.highBitsToInt(version);
+ this.counter = whisperMessage.getCounter();
+ this.previousCounter = whisperMessage.getPreviousCounter();
+ this.ciphertext = whisperMessage.getCiphertext().toByteArray();
+ } catch (InvalidProtocolBufferException | InvalidKeyException | ParseException e) {
+ throw new InvalidMessageException(e);
+ }
+ }
+
+ public WhisperMessage(int messageVersion, SecretKeySpec macKey, ECPublicKey senderRatchetKey,
+ int counter, int previousCounter, byte[] ciphertext,
+ IdentityKey senderIdentityKey,
+ IdentityKey receiverIdentityKey)
+ {
+ byte[] version = {ByteUtil.intsToByteHighAndLow(messageVersion, CURRENT_VERSION)};
+ byte[] message = WhisperProtos.WhisperMessage.newBuilder()
+ .setRatchetKey(ByteString.copyFrom(senderRatchetKey.serialize()))
+ .setCounter(counter)
+ .setPreviousCounter(previousCounter)
+ .setCiphertext(ByteString.copyFrom(ciphertext))
+ .build().toByteArray();
+
+ byte[] mac = getMac(messageVersion, senderIdentityKey, receiverIdentityKey, macKey,
+ ByteUtil.combine(version, message));
+
+ this.serialized = ByteUtil.combine(version, message, mac);
+ this.senderRatchetKey = senderRatchetKey;
+ this.counter = counter;
+ this.previousCounter = previousCounter;
+ this.ciphertext = ciphertext;
+ this.messageVersion = messageVersion;
+ }
+
+ public ECPublicKey getSenderRatchetKey() {
+ return senderRatchetKey;
+ }
+
+ public int getMessageVersion() {
+ return messageVersion;
+ }
+
+ public int getCounter() {
+ return counter;
+ }
+
+ public byte[] getBody() {
+ return ciphertext;
+ }
+
+ public void verifyMac(int messageVersion, IdentityKey senderIdentityKey,
+ IdentityKey receiverIdentityKey, SecretKeySpec macKey)
+ throws InvalidMessageException
+ {
+ byte[][] parts = ByteUtil.split(serialized, serialized.length - MAC_LENGTH, MAC_LENGTH);
+ byte[] ourMac = getMac(messageVersion, senderIdentityKey, receiverIdentityKey, macKey, parts[0]);
+ byte[] theirMac = parts[1];
+
+ if (!MessageDigest.isEqual(ourMac, theirMac)) {
+ throw new InvalidMessageException("Bad Mac!");
+ }
+ }
+
+ private byte[] getMac(int messageVersion,
+ IdentityKey senderIdentityKey,
+ IdentityKey receiverIdentityKey,
+ SecretKeySpec macKey, byte[] serialized)
+ {
+ try {
+ Mac mac = Mac.getInstance("HmacSHA256");
+ mac.init(macKey);
+
+ if (messageVersion >= 3) {
+ mac.update(senderIdentityKey.getPublicKey().serialize());
+ mac.update(receiverIdentityKey.getPublicKey().serialize());
+ }
+
+ byte[] fullMac = mac.doFinal(serialized);
+ return ByteUtil.trim(fullMac, MAC_LENGTH);
+ } catch (NoSuchAlgorithmException | java.security.InvalidKeyException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ @Override
+ public byte[] serialize() {
+ return serialized;
+ }
+
+ @Override
+ public int getType() {
+ return CiphertextMessage.WHISPER_TYPE;
+ }
+
+ public static boolean isLegacy(byte[] message) {
+ return message != null && message.length >= 1 &&
+ ByteUtil.highBitsToInt(message[0]) <= CiphertextMessage.UNSUPPORTED_VERSION;
+ }
+
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/protocol/WhisperProtos.java b/src/main/java/org/whispersystems/libaxolotl/protocol/WhisperProtos.java
new file mode 100644
index 00000000..12ab0272
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/protocol/WhisperProtos.java
@@ -0,0 +1,3532 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: WhisperTextProtocol.proto
+
+package org.whispersystems.libaxolotl.protocol;
+
+public final class WhisperProtos {
+ private WhisperProtos() {}
+ public static void registerAllExtensions(
+ com.google.protobuf.ExtensionRegistry registry) {
+ }
+ public interface WhisperMessageOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional bytes ratchetKey = 1;
+ /**
+ * <code>optional bytes ratchetKey = 1;</code>
+ */
+ boolean hasRatchetKey();
+ /**
+ * <code>optional bytes ratchetKey = 1;</code>
+ */
+ com.google.protobuf.ByteString getRatchetKey();
+
+ // optional uint32 counter = 2;
+ /**
+ * <code>optional uint32 counter = 2;</code>
+ */
+ boolean hasCounter();
+ /**
+ * <code>optional uint32 counter = 2;</code>
+ */
+ int getCounter();
+
+ // optional uint32 previousCounter = 3;
+ /**
+ * <code>optional uint32 previousCounter = 3;</code>
+ */
+ boolean hasPreviousCounter();
+ /**
+ * <code>optional uint32 previousCounter = 3;</code>
+ */
+ int getPreviousCounter();
+
+ // optional bytes ciphertext = 4;
+ /**
+ * <code>optional bytes ciphertext = 4;</code>
+ */
+ boolean hasCiphertext();
+ /**
+ * <code>optional bytes ciphertext = 4;</code>
+ */
+ com.google.protobuf.ByteString getCiphertext();
+ }
+ /**
+ * Protobuf type {@code textsecure.WhisperMessage}
+ */
+ public static final class WhisperMessage extends
+ com.google.protobuf.GeneratedMessage
+ implements WhisperMessageOrBuilder {
+ // Use WhisperMessage.newBuilder() to construct.
+ private WhisperMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private WhisperMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final WhisperMessage defaultInstance;
+ public static WhisperMessage getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public WhisperMessage getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private WhisperMessage(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 10: {
+ bitField0_ |= 0x00000001;
+ ratchetKey_ = input.readBytes();
+ break;
+ }
+ case 16: {
+ bitField0_ |= 0x00000002;
+ counter_ = input.readUInt32();
+ break;
+ }
+ case 24: {
+ bitField0_ |= 0x00000004;
+ previousCounter_ = input.readUInt32();
+ break;
+ }
+ case 34: {
+ bitField0_ |= 0x00000008;
+ ciphertext_ = input.readBytes();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_WhisperMessage_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_WhisperMessage_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage.class, org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<WhisperMessage> PARSER =
+ new com.google.protobuf.AbstractParser<WhisperMessage>() {
+ public WhisperMessage parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new WhisperMessage(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<WhisperMessage> getParserForType() {
+ return PARSER;
+ }
+
+ private int bitField0_;
+ // optional bytes ratchetKey = 1;
+ public static final int RATCHETKEY_FIELD_NUMBER = 1;
+ private com.google.protobuf.ByteString ratchetKey_;
+ /**
+ * <code>optional bytes ratchetKey = 1;</code>
+ */
+ public boolean hasRatchetKey() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional bytes ratchetKey = 1;</code>
+ */
+ public com.google.protobuf.ByteString getRatchetKey() {
+ return ratchetKey_;
+ }
+
+ // optional uint32 counter = 2;
+ public static final int COUNTER_FIELD_NUMBER = 2;
+ private int counter_;
+ /**
+ * <code>optional uint32 counter = 2;</code>
+ */
+ public boolean hasCounter() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional uint32 counter = 2;</code>
+ */
+ public int getCounter() {
+ return counter_;
+ }
+
+ // optional uint32 previousCounter = 3;
+ public static final int PREVIOUSCOUNTER_FIELD_NUMBER = 3;
+ private int previousCounter_;
+ /**
+ * <code>optional uint32 previousCounter = 3;</code>
+ */
+ public boolean hasPreviousCounter() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional uint32 previousCounter = 3;</code>
+ */
+ public int getPreviousCounter() {
+ return previousCounter_;
+ }
+
+ // optional bytes ciphertext = 4;
+ public static final int CIPHERTEXT_FIELD_NUMBER = 4;
+ private com.google.protobuf.ByteString ciphertext_;
+ /**
+ * <code>optional bytes ciphertext = 4;</code>
+ */
+ public boolean hasCiphertext() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+ * <code>optional bytes ciphertext = 4;</code>
+ */
+ public com.google.protobuf.ByteString getCiphertext() {
+ return ciphertext_;
+ }
+
+ private void initFields() {
+ ratchetKey_ = com.google.protobuf.ByteString.EMPTY;
+ counter_ = 0;
+ previousCounter_ = 0;
+ ciphertext_ = com.google.protobuf.ByteString.EMPTY;
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeBytes(1, ratchetKey_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeUInt32(2, counter_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ output.writeUInt32(3, previousCounter_);
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ output.writeBytes(4, ciphertext_);
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(1, ratchetKey_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(2, counter_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(3, previousCounter_);
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(4, ciphertext_);
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.WhisperMessage}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessageOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_WhisperMessage_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_WhisperMessage_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage.class, org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ ratchetKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ counter_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ previousCounter_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000004);
+ ciphertext_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000008);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_WhisperMessage_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage build() {
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage buildPartial() {
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage result = new org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.ratchetKey_ = ratchetKey_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.counter_ = counter_;
+ if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+ to_bitField0_ |= 0x00000004;
+ }
+ result.previousCounter_ = previousCounter_;
+ if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+ to_bitField0_ |= 0x00000008;
+ }
+ result.ciphertext_ = ciphertext_;
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage) {
+ return mergeFrom((org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage other) {
+ if (other == org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage.getDefaultInstance()) return this;
+ if (other.hasRatchetKey()) {
+ setRatchetKey(other.getRatchetKey());
+ }
+ if (other.hasCounter()) {
+ setCounter(other.getCounter());
+ }
+ if (other.hasPreviousCounter()) {
+ setPreviousCounter(other.getPreviousCounter());
+ }
+ if (other.hasCiphertext()) {
+ setCiphertext(other.getCiphertext());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.protocol.WhisperProtos.WhisperMessage) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional bytes ratchetKey = 1;
+ private com.google.protobuf.ByteString ratchetKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes ratchetKey = 1;</code>
+ */
+ public boolean hasRatchetKey() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional bytes ratchetKey = 1;</code>
+ */
+ public com.google.protobuf.ByteString getRatchetKey() {
+ return ratchetKey_;
+ }
+ /**
+ * <code>optional bytes ratchetKey = 1;</code>
+ */
+ public Builder setRatchetKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000001;
+ ratchetKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes ratchetKey = 1;</code>
+ */
+ public Builder clearRatchetKey() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ ratchetKey_ = getDefaultInstance().getRatchetKey();
+ onChanged();
+ return this;
+ }
+
+ // optional uint32 counter = 2;
+ private int counter_ ;
+ /**
+ * <code>optional uint32 counter = 2;</code>
+ */
+ public boolean hasCounter() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional uint32 counter = 2;</code>
+ */
+ public int getCounter() {
+ return counter_;
+ }
+ /**
+ * <code>optional uint32 counter = 2;</code>
+ */
+ public Builder setCounter(int value) {
+ bitField0_ |= 0x00000002;
+ counter_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 counter = 2;</code>
+ */
+ public Builder clearCounter() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ counter_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional uint32 previousCounter = 3;
+ private int previousCounter_ ;
+ /**
+ * <code>optional uint32 previousCounter = 3;</code>
+ */
+ public boolean hasPreviousCounter() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional uint32 previousCounter = 3;</code>
+ */
+ public int getPreviousCounter() {
+ return previousCounter_;
+ }
+ /**
+ * <code>optional uint32 previousCounter = 3;</code>
+ */
+ public Builder setPreviousCounter(int value) {
+ bitField0_ |= 0x00000004;
+ previousCounter_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 previousCounter = 3;</code>
+ */
+ public Builder clearPreviousCounter() {
+ bitField0_ = (bitField0_ & ~0x00000004);
+ previousCounter_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional bytes ciphertext = 4;
+ private com.google.protobuf.ByteString ciphertext_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes ciphertext = 4;</code>
+ */
+ public boolean hasCiphertext() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+ * <code>optional bytes ciphertext = 4;</code>
+ */
+ public com.google.protobuf.ByteString getCiphertext() {
+ return ciphertext_;
+ }
+ /**
+ * <code>optional bytes ciphertext = 4;</code>
+ */
+ public Builder setCiphertext(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000008;
+ ciphertext_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes ciphertext = 4;</code>
+ */
+ public Builder clearCiphertext() {
+ bitField0_ = (bitField0_ & ~0x00000008);
+ ciphertext_ = getDefaultInstance().getCiphertext();
+ onChanged();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.WhisperMessage)
+ }
+
+ static {
+ defaultInstance = new WhisperMessage(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.WhisperMessage)
+ }
+
+ public interface PreKeyWhisperMessageOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional uint32 registrationId = 5;
+ /**
+ * <code>optional uint32 registrationId = 5;</code>
+ */
+ boolean hasRegistrationId();
+ /**
+ * <code>optional uint32 registrationId = 5;</code>
+ */
+ int getRegistrationId();
+
+ // optional uint32 preKeyId = 1;
+ /**
+ * <code>optional uint32 preKeyId = 1;</code>
+ */
+ boolean hasPreKeyId();
+ /**
+ * <code>optional uint32 preKeyId = 1;</code>
+ */
+ int getPreKeyId();
+
+ // optional uint32 signedPreKeyId = 6;
+ /**
+ * <code>optional uint32 signedPreKeyId = 6;</code>
+ */
+ boolean hasSignedPreKeyId();
+ /**
+ * <code>optional uint32 signedPreKeyId = 6;</code>
+ */
+ int getSignedPreKeyId();
+
+ // optional bytes baseKey = 2;
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ boolean hasBaseKey();
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ com.google.protobuf.ByteString getBaseKey();
+
+ // optional bytes identityKey = 3;
+ /**
+ * <code>optional bytes identityKey = 3;</code>
+ */
+ boolean hasIdentityKey();
+ /**
+ * <code>optional bytes identityKey = 3;</code>
+ */
+ com.google.protobuf.ByteString getIdentityKey();
+
+ // optional bytes message = 4;
+ /**
+ * <code>optional bytes message = 4;</code>
+ *
+ * <pre>
+ * WhisperMessage
+ * </pre>
+ */
+ boolean hasMessage();
+ /**
+ * <code>optional bytes message = 4;</code>
+ *
+ * <pre>
+ * WhisperMessage
+ * </pre>
+ */
+ com.google.protobuf.ByteString getMessage();
+ }
+ /**
+ * Protobuf type {@code textsecure.PreKeyWhisperMessage}
+ */
+ public static final class PreKeyWhisperMessage extends
+ com.google.protobuf.GeneratedMessage
+ implements PreKeyWhisperMessageOrBuilder {
+ // Use PreKeyWhisperMessage.newBuilder() to construct.
+ private PreKeyWhisperMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private PreKeyWhisperMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final PreKeyWhisperMessage defaultInstance;
+ public static PreKeyWhisperMessage getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public PreKeyWhisperMessage getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private PreKeyWhisperMessage(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 8: {
+ bitField0_ |= 0x00000002;
+ preKeyId_ = input.readUInt32();
+ break;
+ }
+ case 18: {
+ bitField0_ |= 0x00000008;
+ baseKey_ = input.readBytes();
+ break;
+ }
+ case 26: {
+ bitField0_ |= 0x00000010;
+ identityKey_ = input.readBytes();
+ break;
+ }
+ case 34: {
+ bitField0_ |= 0x00000020;
+ message_ = input.readBytes();
+ break;
+ }
+ case 40: {
+ bitField0_ |= 0x00000001;
+ registrationId_ = input.readUInt32();
+ break;
+ }
+ case 48: {
+ bitField0_ |= 0x00000004;
+ signedPreKeyId_ = input.readUInt32();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_PreKeyWhisperMessage_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_PreKeyWhisperMessage_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage.class, org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<PreKeyWhisperMessage> PARSER =
+ new com.google.protobuf.AbstractParser<PreKeyWhisperMessage>() {
+ public PreKeyWhisperMessage parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new PreKeyWhisperMessage(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<PreKeyWhisperMessage> getParserForType() {
+ return PARSER;
+ }
+
+ private int bitField0_;
+ // optional uint32 registrationId = 5;
+ public static final int REGISTRATIONID_FIELD_NUMBER = 5;
+ private int registrationId_;
+ /**
+ * <code>optional uint32 registrationId = 5;</code>
+ */
+ public boolean hasRegistrationId() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 registrationId = 5;</code>
+ */
+ public int getRegistrationId() {
+ return registrationId_;
+ }
+
+ // optional uint32 preKeyId = 1;
+ public static final int PREKEYID_FIELD_NUMBER = 1;
+ private int preKeyId_;
+ /**
+ * <code>optional uint32 preKeyId = 1;</code>
+ */
+ public boolean hasPreKeyId() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional uint32 preKeyId = 1;</code>
+ */
+ public int getPreKeyId() {
+ return preKeyId_;
+ }
+
+ // optional uint32 signedPreKeyId = 6;
+ public static final int SIGNEDPREKEYID_FIELD_NUMBER = 6;
+ private int signedPreKeyId_;
+ /**
+ * <code>optional uint32 signedPreKeyId = 6;</code>
+ */
+ public boolean hasSignedPreKeyId() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional uint32 signedPreKeyId = 6;</code>
+ */
+ public int getSignedPreKeyId() {
+ return signedPreKeyId_;
+ }
+
+ // optional bytes baseKey = 2;
+ public static final int BASEKEY_FIELD_NUMBER = 2;
+ private com.google.protobuf.ByteString baseKey_;
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ public boolean hasBaseKey() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ public com.google.protobuf.ByteString getBaseKey() {
+ return baseKey_;
+ }
+
+ // optional bytes identityKey = 3;
+ public static final int IDENTITYKEY_FIELD_NUMBER = 3;
+ private com.google.protobuf.ByteString identityKey_;
+ /**
+ * <code>optional bytes identityKey = 3;</code>
+ */
+ public boolean hasIdentityKey() {
+ return ((bitField0_ & 0x00000010) == 0x00000010);
+ }
+ /**
+ * <code>optional bytes identityKey = 3;</code>
+ */
+ public com.google.protobuf.ByteString getIdentityKey() {
+ return identityKey_;
+ }
+
+ // optional bytes message = 4;
+ public static final int MESSAGE_FIELD_NUMBER = 4;
+ private com.google.protobuf.ByteString message_;
+ /**
+ * <code>optional bytes message = 4;</code>
+ *
+ * <pre>
+ * WhisperMessage
+ * </pre>
+ */
+ public boolean hasMessage() {
+ return ((bitField0_ & 0x00000020) == 0x00000020);
+ }
+ /**
+ * <code>optional bytes message = 4;</code>
+ *
+ * <pre>
+ * WhisperMessage
+ * </pre>
+ */
+ public com.google.protobuf.ByteString getMessage() {
+ return message_;
+ }
+
+ private void initFields() {
+ registrationId_ = 0;
+ preKeyId_ = 0;
+ signedPreKeyId_ = 0;
+ baseKey_ = com.google.protobuf.ByteString.EMPTY;
+ identityKey_ = com.google.protobuf.ByteString.EMPTY;
+ message_ = com.google.protobuf.ByteString.EMPTY;
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeUInt32(1, preKeyId_);
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ output.writeBytes(2, baseKey_);
+ }
+ if (((bitField0_ & 0x00000010) == 0x00000010)) {
+ output.writeBytes(3, identityKey_);
+ }
+ if (((bitField0_ & 0x00000020) == 0x00000020)) {
+ output.writeBytes(4, message_);
+ }
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeUInt32(5, registrationId_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ output.writeUInt32(6, signedPreKeyId_);
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(1, preKeyId_);
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(2, baseKey_);
+ }
+ if (((bitField0_ & 0x00000010) == 0x00000010)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(3, identityKey_);
+ }
+ if (((bitField0_ & 0x00000020) == 0x00000020)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(4, message_);
+ }
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(5, registrationId_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(6, signedPreKeyId_);
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.PreKeyWhisperMessage}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessageOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_PreKeyWhisperMessage_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_PreKeyWhisperMessage_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage.class, org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ registrationId_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ preKeyId_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ signedPreKeyId_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000004);
+ baseKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000008);
+ identityKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000010);
+ message_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000020);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_PreKeyWhisperMessage_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage build() {
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage buildPartial() {
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage result = new org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.registrationId_ = registrationId_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.preKeyId_ = preKeyId_;
+ if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+ to_bitField0_ |= 0x00000004;
+ }
+ result.signedPreKeyId_ = signedPreKeyId_;
+ if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+ to_bitField0_ |= 0x00000008;
+ }
+ result.baseKey_ = baseKey_;
+ if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+ to_bitField0_ |= 0x00000010;
+ }
+ result.identityKey_ = identityKey_;
+ if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
+ to_bitField0_ |= 0x00000020;
+ }
+ result.message_ = message_;
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage) {
+ return mergeFrom((org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage other) {
+ if (other == org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage.getDefaultInstance()) return this;
+ if (other.hasRegistrationId()) {
+ setRegistrationId(other.getRegistrationId());
+ }
+ if (other.hasPreKeyId()) {
+ setPreKeyId(other.getPreKeyId());
+ }
+ if (other.hasSignedPreKeyId()) {
+ setSignedPreKeyId(other.getSignedPreKeyId());
+ }
+ if (other.hasBaseKey()) {
+ setBaseKey(other.getBaseKey());
+ }
+ if (other.hasIdentityKey()) {
+ setIdentityKey(other.getIdentityKey());
+ }
+ if (other.hasMessage()) {
+ setMessage(other.getMessage());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.protocol.WhisperProtos.PreKeyWhisperMessage) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional uint32 registrationId = 5;
+ private int registrationId_ ;
+ /**
+ * <code>optional uint32 registrationId = 5;</code>
+ */
+ public boolean hasRegistrationId() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 registrationId = 5;</code>
+ */
+ public int getRegistrationId() {
+ return registrationId_;
+ }
+ /**
+ * <code>optional uint32 registrationId = 5;</code>
+ */
+ public Builder setRegistrationId(int value) {
+ bitField0_ |= 0x00000001;
+ registrationId_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 registrationId = 5;</code>
+ */
+ public Builder clearRegistrationId() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ registrationId_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional uint32 preKeyId = 1;
+ private int preKeyId_ ;
+ /**
+ * <code>optional uint32 preKeyId = 1;</code>
+ */
+ public boolean hasPreKeyId() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional uint32 preKeyId = 1;</code>
+ */
+ public int getPreKeyId() {
+ return preKeyId_;
+ }
+ /**
+ * <code>optional uint32 preKeyId = 1;</code>
+ */
+ public Builder setPreKeyId(int value) {
+ bitField0_ |= 0x00000002;
+ preKeyId_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 preKeyId = 1;</code>
+ */
+ public Builder clearPreKeyId() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ preKeyId_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional uint32 signedPreKeyId = 6;
+ private int signedPreKeyId_ ;
+ /**
+ * <code>optional uint32 signedPreKeyId = 6;</code>
+ */
+ public boolean hasSignedPreKeyId() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional uint32 signedPreKeyId = 6;</code>
+ */
+ public int getSignedPreKeyId() {
+ return signedPreKeyId_;
+ }
+ /**
+ * <code>optional uint32 signedPreKeyId = 6;</code>
+ */
+ public Builder setSignedPreKeyId(int value) {
+ bitField0_ |= 0x00000004;
+ signedPreKeyId_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 signedPreKeyId = 6;</code>
+ */
+ public Builder clearSignedPreKeyId() {
+ bitField0_ = (bitField0_ & ~0x00000004);
+ signedPreKeyId_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional bytes baseKey = 2;
+ private com.google.protobuf.ByteString baseKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ public boolean hasBaseKey() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ public com.google.protobuf.ByteString getBaseKey() {
+ return baseKey_;
+ }
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ public Builder setBaseKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000008;
+ baseKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ public Builder clearBaseKey() {
+ bitField0_ = (bitField0_ & ~0x00000008);
+ baseKey_ = getDefaultInstance().getBaseKey();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes identityKey = 3;
+ private com.google.protobuf.ByteString identityKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes identityKey = 3;</code>
+ */
+ public boolean hasIdentityKey() {
+ return ((bitField0_ & 0x00000010) == 0x00000010);
+ }
+ /**
+ * <code>optional bytes identityKey = 3;</code>
+ */
+ public com.google.protobuf.ByteString getIdentityKey() {
+ return identityKey_;
+ }
+ /**
+ * <code>optional bytes identityKey = 3;</code>
+ */
+ public Builder setIdentityKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000010;
+ identityKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes identityKey = 3;</code>
+ */
+ public Builder clearIdentityKey() {
+ bitField0_ = (bitField0_ & ~0x00000010);
+ identityKey_ = getDefaultInstance().getIdentityKey();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes message = 4;
+ private com.google.protobuf.ByteString message_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes message = 4;</code>
+ *
+ * <pre>
+ * WhisperMessage
+ * </pre>
+ */
+ public boolean hasMessage() {
+ return ((bitField0_ & 0x00000020) == 0x00000020);
+ }
+ /**
+ * <code>optional bytes message = 4;</code>
+ *
+ * <pre>
+ * WhisperMessage
+ * </pre>
+ */
+ public com.google.protobuf.ByteString getMessage() {
+ return message_;
+ }
+ /**
+ * <code>optional bytes message = 4;</code>
+ *
+ * <pre>
+ * WhisperMessage
+ * </pre>
+ */
+ public Builder setMessage(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000020;
+ message_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes message = 4;</code>
+ *
+ * <pre>
+ * WhisperMessage
+ * </pre>
+ */
+ public Builder clearMessage() {
+ bitField0_ = (bitField0_ & ~0x00000020);
+ message_ = getDefaultInstance().getMessage();
+ onChanged();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.PreKeyWhisperMessage)
+ }
+
+ static {
+ defaultInstance = new PreKeyWhisperMessage(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.PreKeyWhisperMessage)
+ }
+
+ public interface KeyExchangeMessageOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional uint32 id = 1;
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ boolean hasId();
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ int getId();
+
+ // optional bytes baseKey = 2;
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ boolean hasBaseKey();
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ com.google.protobuf.ByteString getBaseKey();
+
+ // optional bytes ratchetKey = 3;
+ /**
+ * <code>optional bytes ratchetKey = 3;</code>
+ */
+ boolean hasRatchetKey();
+ /**
+ * <code>optional bytes ratchetKey = 3;</code>
+ */
+ com.google.protobuf.ByteString getRatchetKey();
+
+ // optional bytes identityKey = 4;
+ /**
+ * <code>optional bytes identityKey = 4;</code>
+ */
+ boolean hasIdentityKey();
+ /**
+ * <code>optional bytes identityKey = 4;</code>
+ */
+ com.google.protobuf.ByteString getIdentityKey();
+
+ // optional bytes baseKeySignature = 5;
+ /**
+ * <code>optional bytes baseKeySignature = 5;</code>
+ */
+ boolean hasBaseKeySignature();
+ /**
+ * <code>optional bytes baseKeySignature = 5;</code>
+ */
+ com.google.protobuf.ByteString getBaseKeySignature();
+ }
+ /**
+ * Protobuf type {@code textsecure.KeyExchangeMessage}
+ */
+ public static final class KeyExchangeMessage extends
+ com.google.protobuf.GeneratedMessage
+ implements KeyExchangeMessageOrBuilder {
+ // Use KeyExchangeMessage.newBuilder() to construct.
+ private KeyExchangeMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private KeyExchangeMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final KeyExchangeMessage defaultInstance;
+ public static KeyExchangeMessage getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public KeyExchangeMessage getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private KeyExchangeMessage(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 8: {
+ bitField0_ |= 0x00000001;
+ id_ = input.readUInt32();
+ break;
+ }
+ case 18: {
+ bitField0_ |= 0x00000002;
+ baseKey_ = input.readBytes();
+ break;
+ }
+ case 26: {
+ bitField0_ |= 0x00000004;
+ ratchetKey_ = input.readBytes();
+ break;
+ }
+ case 34: {
+ bitField0_ |= 0x00000008;
+ identityKey_ = input.readBytes();
+ break;
+ }
+ case 42: {
+ bitField0_ |= 0x00000010;
+ baseKeySignature_ = input.readBytes();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_KeyExchangeMessage_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_KeyExchangeMessage_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage.class, org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<KeyExchangeMessage> PARSER =
+ new com.google.protobuf.AbstractParser<KeyExchangeMessage>() {
+ public KeyExchangeMessage parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new KeyExchangeMessage(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<KeyExchangeMessage> getParserForType() {
+ return PARSER;
+ }
+
+ private int bitField0_;
+ // optional uint32 id = 1;
+ public static final int ID_FIELD_NUMBER = 1;
+ private int id_;
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public boolean hasId() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public int getId() {
+ return id_;
+ }
+
+ // optional bytes baseKey = 2;
+ public static final int BASEKEY_FIELD_NUMBER = 2;
+ private com.google.protobuf.ByteString baseKey_;
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ public boolean hasBaseKey() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ public com.google.protobuf.ByteString getBaseKey() {
+ return baseKey_;
+ }
+
+ // optional bytes ratchetKey = 3;
+ public static final int RATCHETKEY_FIELD_NUMBER = 3;
+ private com.google.protobuf.ByteString ratchetKey_;
+ /**
+ * <code>optional bytes ratchetKey = 3;</code>
+ */
+ public boolean hasRatchetKey() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional bytes ratchetKey = 3;</code>
+ */
+ public com.google.protobuf.ByteString getRatchetKey() {
+ return ratchetKey_;
+ }
+
+ // optional bytes identityKey = 4;
+ public static final int IDENTITYKEY_FIELD_NUMBER = 4;
+ private com.google.protobuf.ByteString identityKey_;
+ /**
+ * <code>optional bytes identityKey = 4;</code>
+ */
+ public boolean hasIdentityKey() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+ * <code>optional bytes identityKey = 4;</code>
+ */
+ public com.google.protobuf.ByteString getIdentityKey() {
+ return identityKey_;
+ }
+
+ // optional bytes baseKeySignature = 5;
+ public static final int BASEKEYSIGNATURE_FIELD_NUMBER = 5;
+ private com.google.protobuf.ByteString baseKeySignature_;
+ /**
+ * <code>optional bytes baseKeySignature = 5;</code>
+ */
+ public boolean hasBaseKeySignature() {
+ return ((bitField0_ & 0x00000010) == 0x00000010);
+ }
+ /**
+ * <code>optional bytes baseKeySignature = 5;</code>
+ */
+ public com.google.protobuf.ByteString getBaseKeySignature() {
+ return baseKeySignature_;
+ }
+
+ private void initFields() {
+ id_ = 0;
+ baseKey_ = com.google.protobuf.ByteString.EMPTY;
+ ratchetKey_ = com.google.protobuf.ByteString.EMPTY;
+ identityKey_ = com.google.protobuf.ByteString.EMPTY;
+ baseKeySignature_ = com.google.protobuf.ByteString.EMPTY;
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeUInt32(1, id_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeBytes(2, baseKey_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ output.writeBytes(3, ratchetKey_);
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ output.writeBytes(4, identityKey_);
+ }
+ if (((bitField0_ & 0x00000010) == 0x00000010)) {
+ output.writeBytes(5, baseKeySignature_);
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(1, id_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(2, baseKey_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(3, ratchetKey_);
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(4, identityKey_);
+ }
+ if (((bitField0_ & 0x00000010) == 0x00000010)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(5, baseKeySignature_);
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.KeyExchangeMessage}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessageOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_KeyExchangeMessage_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_KeyExchangeMessage_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage.class, org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ id_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ baseKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ ratchetKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000004);
+ identityKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000008);
+ baseKeySignature_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000010);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_KeyExchangeMessage_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage build() {
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage buildPartial() {
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage result = new org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.id_ = id_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.baseKey_ = baseKey_;
+ if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+ to_bitField0_ |= 0x00000004;
+ }
+ result.ratchetKey_ = ratchetKey_;
+ if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+ to_bitField0_ |= 0x00000008;
+ }
+ result.identityKey_ = identityKey_;
+ if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+ to_bitField0_ |= 0x00000010;
+ }
+ result.baseKeySignature_ = baseKeySignature_;
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage) {
+ return mergeFrom((org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage other) {
+ if (other == org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage.getDefaultInstance()) return this;
+ if (other.hasId()) {
+ setId(other.getId());
+ }
+ if (other.hasBaseKey()) {
+ setBaseKey(other.getBaseKey());
+ }
+ if (other.hasRatchetKey()) {
+ setRatchetKey(other.getRatchetKey());
+ }
+ if (other.hasIdentityKey()) {
+ setIdentityKey(other.getIdentityKey());
+ }
+ if (other.hasBaseKeySignature()) {
+ setBaseKeySignature(other.getBaseKeySignature());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.protocol.WhisperProtos.KeyExchangeMessage) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional uint32 id = 1;
+ private int id_ ;
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public boolean hasId() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public int getId() {
+ return id_;
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public Builder setId(int value) {
+ bitField0_ |= 0x00000001;
+ id_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public Builder clearId() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ id_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional bytes baseKey = 2;
+ private com.google.protobuf.ByteString baseKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ public boolean hasBaseKey() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ public com.google.protobuf.ByteString getBaseKey() {
+ return baseKey_;
+ }
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ public Builder setBaseKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000002;
+ baseKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ public Builder clearBaseKey() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ baseKey_ = getDefaultInstance().getBaseKey();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes ratchetKey = 3;
+ private com.google.protobuf.ByteString ratchetKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes ratchetKey = 3;</code>
+ */
+ public boolean hasRatchetKey() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional bytes ratchetKey = 3;</code>
+ */
+ public com.google.protobuf.ByteString getRatchetKey() {
+ return ratchetKey_;
+ }
+ /**
+ * <code>optional bytes ratchetKey = 3;</code>
+ */
+ public Builder setRatchetKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000004;
+ ratchetKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes ratchetKey = 3;</code>
+ */
+ public Builder clearRatchetKey() {
+ bitField0_ = (bitField0_ & ~0x00000004);
+ ratchetKey_ = getDefaultInstance().getRatchetKey();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes identityKey = 4;
+ private com.google.protobuf.ByteString identityKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes identityKey = 4;</code>
+ */
+ public boolean hasIdentityKey() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+ * <code>optional bytes identityKey = 4;</code>
+ */
+ public com.google.protobuf.ByteString getIdentityKey() {
+ return identityKey_;
+ }
+ /**
+ * <code>optional bytes identityKey = 4;</code>
+ */
+ public Builder setIdentityKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000008;
+ identityKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes identityKey = 4;</code>
+ */
+ public Builder clearIdentityKey() {
+ bitField0_ = (bitField0_ & ~0x00000008);
+ identityKey_ = getDefaultInstance().getIdentityKey();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes baseKeySignature = 5;
+ private com.google.protobuf.ByteString baseKeySignature_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes baseKeySignature = 5;</code>
+ */
+ public boolean hasBaseKeySignature() {
+ return ((bitField0_ & 0x00000010) == 0x00000010);
+ }
+ /**
+ * <code>optional bytes baseKeySignature = 5;</code>
+ */
+ public com.google.protobuf.ByteString getBaseKeySignature() {
+ return baseKeySignature_;
+ }
+ /**
+ * <code>optional bytes baseKeySignature = 5;</code>
+ */
+ public Builder setBaseKeySignature(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000010;
+ baseKeySignature_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes baseKeySignature = 5;</code>
+ */
+ public Builder clearBaseKeySignature() {
+ bitField0_ = (bitField0_ & ~0x00000010);
+ baseKeySignature_ = getDefaultInstance().getBaseKeySignature();
+ onChanged();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.KeyExchangeMessage)
+ }
+
+ static {
+ defaultInstance = new KeyExchangeMessage(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.KeyExchangeMessage)
+ }
+
+ public interface SenderKeyMessageOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional uint32 id = 1;
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ boolean hasId();
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ int getId();
+
+ // optional uint32 iteration = 2;
+ /**
+ * <code>optional uint32 iteration = 2;</code>
+ */
+ boolean hasIteration();
+ /**
+ * <code>optional uint32 iteration = 2;</code>
+ */
+ int getIteration();
+
+ // optional bytes ciphertext = 3;
+ /**
+ * <code>optional bytes ciphertext = 3;</code>
+ */
+ boolean hasCiphertext();
+ /**
+ * <code>optional bytes ciphertext = 3;</code>
+ */
+ com.google.protobuf.ByteString getCiphertext();
+ }
+ /**
+ * Protobuf type {@code textsecure.SenderKeyMessage}
+ */
+ public static final class SenderKeyMessage extends
+ com.google.protobuf.GeneratedMessage
+ implements SenderKeyMessageOrBuilder {
+ // Use SenderKeyMessage.newBuilder() to construct.
+ private SenderKeyMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private SenderKeyMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final SenderKeyMessage defaultInstance;
+ public static SenderKeyMessage getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public SenderKeyMessage getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private SenderKeyMessage(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 8: {
+ bitField0_ |= 0x00000001;
+ id_ = input.readUInt32();
+ break;
+ }
+ case 16: {
+ bitField0_ |= 0x00000002;
+ iteration_ = input.readUInt32();
+ break;
+ }
+ case 26: {
+ bitField0_ |= 0x00000004;
+ ciphertext_ = input.readBytes();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_SenderKeyMessage_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_SenderKeyMessage_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage.class, org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<SenderKeyMessage> PARSER =
+ new com.google.protobuf.AbstractParser<SenderKeyMessage>() {
+ public SenderKeyMessage parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new SenderKeyMessage(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<SenderKeyMessage> getParserForType() {
+ return PARSER;
+ }
+
+ private int bitField0_;
+ // optional uint32 id = 1;
+ public static final int ID_FIELD_NUMBER = 1;
+ private int id_;
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public boolean hasId() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public int getId() {
+ return id_;
+ }
+
+ // optional uint32 iteration = 2;
+ public static final int ITERATION_FIELD_NUMBER = 2;
+ private int iteration_;
+ /**
+ * <code>optional uint32 iteration = 2;</code>
+ */
+ public boolean hasIteration() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional uint32 iteration = 2;</code>
+ */
+ public int getIteration() {
+ return iteration_;
+ }
+
+ // optional bytes ciphertext = 3;
+ public static final int CIPHERTEXT_FIELD_NUMBER = 3;
+ private com.google.protobuf.ByteString ciphertext_;
+ /**
+ * <code>optional bytes ciphertext = 3;</code>
+ */
+ public boolean hasCiphertext() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional bytes ciphertext = 3;</code>
+ */
+ public com.google.protobuf.ByteString getCiphertext() {
+ return ciphertext_;
+ }
+
+ private void initFields() {
+ id_ = 0;
+ iteration_ = 0;
+ ciphertext_ = com.google.protobuf.ByteString.EMPTY;
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeUInt32(1, id_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeUInt32(2, iteration_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ output.writeBytes(3, ciphertext_);
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(1, id_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(2, iteration_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(3, ciphertext_);
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.SenderKeyMessage}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessageOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_SenderKeyMessage_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_SenderKeyMessage_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage.class, org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ id_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ iteration_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ ciphertext_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000004);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_SenderKeyMessage_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage build() {
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage buildPartial() {
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage result = new org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.id_ = id_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.iteration_ = iteration_;
+ if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+ to_bitField0_ |= 0x00000004;
+ }
+ result.ciphertext_ = ciphertext_;
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage) {
+ return mergeFrom((org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage other) {
+ if (other == org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage.getDefaultInstance()) return this;
+ if (other.hasId()) {
+ setId(other.getId());
+ }
+ if (other.hasIteration()) {
+ setIteration(other.getIteration());
+ }
+ if (other.hasCiphertext()) {
+ setCiphertext(other.getCiphertext());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyMessage) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional uint32 id = 1;
+ private int id_ ;
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public boolean hasId() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public int getId() {
+ return id_;
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public Builder setId(int value) {
+ bitField0_ |= 0x00000001;
+ id_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public Builder clearId() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ id_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional uint32 iteration = 2;
+ private int iteration_ ;
+ /**
+ * <code>optional uint32 iteration = 2;</code>
+ */
+ public boolean hasIteration() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional uint32 iteration = 2;</code>
+ */
+ public int getIteration() {
+ return iteration_;
+ }
+ /**
+ * <code>optional uint32 iteration = 2;</code>
+ */
+ public Builder setIteration(int value) {
+ bitField0_ |= 0x00000002;
+ iteration_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 iteration = 2;</code>
+ */
+ public Builder clearIteration() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ iteration_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional bytes ciphertext = 3;
+ private com.google.protobuf.ByteString ciphertext_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes ciphertext = 3;</code>
+ */
+ public boolean hasCiphertext() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional bytes ciphertext = 3;</code>
+ */
+ public com.google.protobuf.ByteString getCiphertext() {
+ return ciphertext_;
+ }
+ /**
+ * <code>optional bytes ciphertext = 3;</code>
+ */
+ public Builder setCiphertext(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000004;
+ ciphertext_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes ciphertext = 3;</code>
+ */
+ public Builder clearCiphertext() {
+ bitField0_ = (bitField0_ & ~0x00000004);
+ ciphertext_ = getDefaultInstance().getCiphertext();
+ onChanged();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.SenderKeyMessage)
+ }
+
+ static {
+ defaultInstance = new SenderKeyMessage(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.SenderKeyMessage)
+ }
+
+ public interface SenderKeyDistributionMessageOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional uint32 id = 1;
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ boolean hasId();
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ int getId();
+
+ // optional uint32 iteration = 2;
+ /**
+ * <code>optional uint32 iteration = 2;</code>
+ */
+ boolean hasIteration();
+ /**
+ * <code>optional uint32 iteration = 2;</code>
+ */
+ int getIteration();
+
+ // optional bytes chainKey = 3;
+ /**
+ * <code>optional bytes chainKey = 3;</code>
+ */
+ boolean hasChainKey();
+ /**
+ * <code>optional bytes chainKey = 3;</code>
+ */
+ com.google.protobuf.ByteString getChainKey();
+
+ // optional bytes signingKey = 4;
+ /**
+ * <code>optional bytes signingKey = 4;</code>
+ */
+ boolean hasSigningKey();
+ /**
+ * <code>optional bytes signingKey = 4;</code>
+ */
+ com.google.protobuf.ByteString getSigningKey();
+ }
+ /**
+ * Protobuf type {@code textsecure.SenderKeyDistributionMessage}
+ */
+ public static final class SenderKeyDistributionMessage extends
+ com.google.protobuf.GeneratedMessage
+ implements SenderKeyDistributionMessageOrBuilder {
+ // Use SenderKeyDistributionMessage.newBuilder() to construct.
+ private SenderKeyDistributionMessage(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private SenderKeyDistributionMessage(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final SenderKeyDistributionMessage defaultInstance;
+ public static SenderKeyDistributionMessage getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public SenderKeyDistributionMessage getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private SenderKeyDistributionMessage(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 8: {
+ bitField0_ |= 0x00000001;
+ id_ = input.readUInt32();
+ break;
+ }
+ case 16: {
+ bitField0_ |= 0x00000002;
+ iteration_ = input.readUInt32();
+ break;
+ }
+ case 26: {
+ bitField0_ |= 0x00000004;
+ chainKey_ = input.readBytes();
+ break;
+ }
+ case 34: {
+ bitField0_ |= 0x00000008;
+ signingKey_ = input.readBytes();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_SenderKeyDistributionMessage_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_SenderKeyDistributionMessage_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage.class, org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<SenderKeyDistributionMessage> PARSER =
+ new com.google.protobuf.AbstractParser<SenderKeyDistributionMessage>() {
+ public SenderKeyDistributionMessage parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new SenderKeyDistributionMessage(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<SenderKeyDistributionMessage> getParserForType() {
+ return PARSER;
+ }
+
+ private int bitField0_;
+ // optional uint32 id = 1;
+ public static final int ID_FIELD_NUMBER = 1;
+ private int id_;
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public boolean hasId() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public int getId() {
+ return id_;
+ }
+
+ // optional uint32 iteration = 2;
+ public static final int ITERATION_FIELD_NUMBER = 2;
+ private int iteration_;
+ /**
+ * <code>optional uint32 iteration = 2;</code>
+ */
+ public boolean hasIteration() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional uint32 iteration = 2;</code>
+ */
+ public int getIteration() {
+ return iteration_;
+ }
+
+ // optional bytes chainKey = 3;
+ public static final int CHAINKEY_FIELD_NUMBER = 3;
+ private com.google.protobuf.ByteString chainKey_;
+ /**
+ * <code>optional bytes chainKey = 3;</code>
+ */
+ public boolean hasChainKey() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional bytes chainKey = 3;</code>
+ */
+ public com.google.protobuf.ByteString getChainKey() {
+ return chainKey_;
+ }
+
+ // optional bytes signingKey = 4;
+ public static final int SIGNINGKEY_FIELD_NUMBER = 4;
+ private com.google.protobuf.ByteString signingKey_;
+ /**
+ * <code>optional bytes signingKey = 4;</code>
+ */
+ public boolean hasSigningKey() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+ * <code>optional bytes signingKey = 4;</code>
+ */
+ public com.google.protobuf.ByteString getSigningKey() {
+ return signingKey_;
+ }
+
+ private void initFields() {
+ id_ = 0;
+ iteration_ = 0;
+ chainKey_ = com.google.protobuf.ByteString.EMPTY;
+ signingKey_ = com.google.protobuf.ByteString.EMPTY;
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeUInt32(1, id_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeUInt32(2, iteration_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ output.writeBytes(3, chainKey_);
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ output.writeBytes(4, signingKey_);
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(1, id_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(2, iteration_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(3, chainKey_);
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(4, signingKey_);
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.SenderKeyDistributionMessage}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessageOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_SenderKeyDistributionMessage_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_SenderKeyDistributionMessage_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage.class, org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ id_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ iteration_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ chainKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000004);
+ signingKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000008);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.internal_static_textsecure_SenderKeyDistributionMessage_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage build() {
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage buildPartial() {
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage result = new org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.id_ = id_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.iteration_ = iteration_;
+ if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+ to_bitField0_ |= 0x00000004;
+ }
+ result.chainKey_ = chainKey_;
+ if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+ to_bitField0_ |= 0x00000008;
+ }
+ result.signingKey_ = signingKey_;
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage) {
+ return mergeFrom((org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage other) {
+ if (other == org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage.getDefaultInstance()) return this;
+ if (other.hasId()) {
+ setId(other.getId());
+ }
+ if (other.hasIteration()) {
+ setIteration(other.getIteration());
+ }
+ if (other.hasChainKey()) {
+ setChainKey(other.getChainKey());
+ }
+ if (other.hasSigningKey()) {
+ setSigningKey(other.getSigningKey());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.protocol.WhisperProtos.SenderKeyDistributionMessage) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional uint32 id = 1;
+ private int id_ ;
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public boolean hasId() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public int getId() {
+ return id_;
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public Builder setId(int value) {
+ bitField0_ |= 0x00000001;
+ id_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public Builder clearId() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ id_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional uint32 iteration = 2;
+ private int iteration_ ;
+ /**
+ * <code>optional uint32 iteration = 2;</code>
+ */
+ public boolean hasIteration() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional uint32 iteration = 2;</code>
+ */
+ public int getIteration() {
+ return iteration_;
+ }
+ /**
+ * <code>optional uint32 iteration = 2;</code>
+ */
+ public Builder setIteration(int value) {
+ bitField0_ |= 0x00000002;
+ iteration_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 iteration = 2;</code>
+ */
+ public Builder clearIteration() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ iteration_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional bytes chainKey = 3;
+ private com.google.protobuf.ByteString chainKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes chainKey = 3;</code>
+ */
+ public boolean hasChainKey() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional bytes chainKey = 3;</code>
+ */
+ public com.google.protobuf.ByteString getChainKey() {
+ return chainKey_;
+ }
+ /**
+ * <code>optional bytes chainKey = 3;</code>
+ */
+ public Builder setChainKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000004;
+ chainKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes chainKey = 3;</code>
+ */
+ public Builder clearChainKey() {
+ bitField0_ = (bitField0_ & ~0x00000004);
+ chainKey_ = getDefaultInstance().getChainKey();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes signingKey = 4;
+ private com.google.protobuf.ByteString signingKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes signingKey = 4;</code>
+ */
+ public boolean hasSigningKey() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+ * <code>optional bytes signingKey = 4;</code>
+ */
+ public com.google.protobuf.ByteString getSigningKey() {
+ return signingKey_;
+ }
+ /**
+ * <code>optional bytes signingKey = 4;</code>
+ */
+ public Builder setSigningKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000008;
+ signingKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes signingKey = 4;</code>
+ */
+ public Builder clearSigningKey() {
+ bitField0_ = (bitField0_ & ~0x00000008);
+ signingKey_ = getDefaultInstance().getSigningKey();
+ onChanged();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.SenderKeyDistributionMessage)
+ }
+
+ static {
+ defaultInstance = new SenderKeyDistributionMessage(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.SenderKeyDistributionMessage)
+ }
+
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_WhisperMessage_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_WhisperMessage_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_PreKeyWhisperMessage_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_PreKeyWhisperMessage_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_KeyExchangeMessage_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_KeyExchangeMessage_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_SenderKeyMessage_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_SenderKeyMessage_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_SenderKeyDistributionMessage_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_SenderKeyDistributionMessage_fieldAccessorTable;
+
+ public static com.google.protobuf.Descriptors.FileDescriptor
+ getDescriptor() {
+ return descriptor;
+ }
+ private static com.google.protobuf.Descriptors.FileDescriptor
+ descriptor;
+ static {
+ java.lang.String[] descriptorData = {
+ "\n\031WhisperTextProtocol.proto\022\ntextsecure\"" +
+ "b\n\016WhisperMessage\022\022\n\nratchetKey\030\001 \001(\014\022\017\n" +
+ "\007counter\030\002 \001(\r\022\027\n\017previousCounter\030\003 \001(\r\022" +
+ "\022\n\nciphertext\030\004 \001(\014\"\217\001\n\024PreKeyWhisperMes" +
+ "sage\022\026\n\016registrationId\030\005 \001(\r\022\020\n\010preKeyId" +
+ "\030\001 \001(\r\022\026\n\016signedPreKeyId\030\006 \001(\r\022\017\n\007baseKe" +
+ "y\030\002 \001(\014\022\023\n\013identityKey\030\003 \001(\014\022\017\n\007message\030" +
+ "\004 \001(\014\"t\n\022KeyExchangeMessage\022\n\n\002id\030\001 \001(\r\022" +
+ "\017\n\007baseKey\030\002 \001(\014\022\022\n\nratchetKey\030\003 \001(\014\022\023\n\013" +
+ "identityKey\030\004 \001(\014\022\030\n\020baseKeySignature\030\005 ",
+ "\001(\014\"E\n\020SenderKeyMessage\022\n\n\002id\030\001 \001(\r\022\021\n\ti" +
+ "teration\030\002 \001(\r\022\022\n\nciphertext\030\003 \001(\014\"c\n\034Se" +
+ "nderKeyDistributionMessage\022\n\n\002id\030\001 \001(\r\022\021" +
+ "\n\titeration\030\002 \001(\r\022\020\n\010chainKey\030\003 \001(\014\022\022\n\ns" +
+ "igningKey\030\004 \001(\014B7\n&org.whispersystems.li" +
+ "baxolotl.protocolB\rWhisperProtos"
+ };
+ com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
+ new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
+ public com.google.protobuf.ExtensionRegistry assignDescriptors(
+ com.google.protobuf.Descriptors.FileDescriptor root) {
+ descriptor = root;
+ internal_static_textsecure_WhisperMessage_descriptor =
+ getDescriptor().getMessageTypes().get(0);
+ internal_static_textsecure_WhisperMessage_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_WhisperMessage_descriptor,
+ new java.lang.String[] { "RatchetKey", "Counter", "PreviousCounter", "Ciphertext", });
+ internal_static_textsecure_PreKeyWhisperMessage_descriptor =
+ getDescriptor().getMessageTypes().get(1);
+ internal_static_textsecure_PreKeyWhisperMessage_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_PreKeyWhisperMessage_descriptor,
+ new java.lang.String[] { "RegistrationId", "PreKeyId", "SignedPreKeyId", "BaseKey", "IdentityKey", "Message", });
+ internal_static_textsecure_KeyExchangeMessage_descriptor =
+ getDescriptor().getMessageTypes().get(2);
+ internal_static_textsecure_KeyExchangeMessage_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_KeyExchangeMessage_descriptor,
+ new java.lang.String[] { "Id", "BaseKey", "RatchetKey", "IdentityKey", "BaseKeySignature", });
+ internal_static_textsecure_SenderKeyMessage_descriptor =
+ getDescriptor().getMessageTypes().get(3);
+ internal_static_textsecure_SenderKeyMessage_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_SenderKeyMessage_descriptor,
+ new java.lang.String[] { "Id", "Iteration", "Ciphertext", });
+ internal_static_textsecure_SenderKeyDistributionMessage_descriptor =
+ getDescriptor().getMessageTypes().get(4);
+ internal_static_textsecure_SenderKeyDistributionMessage_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_SenderKeyDistributionMessage_descriptor,
+ new java.lang.String[] { "Id", "Iteration", "ChainKey", "SigningKey", });
+ return null;
+ }
+ };
+ com.google.protobuf.Descriptors.FileDescriptor
+ .internalBuildGeneratedFileFrom(descriptorData,
+ new com.google.protobuf.Descriptors.FileDescriptor[] {
+ }, assigner);
+ }
+
+ // @@protoc_insertion_point(outer_class_scope)
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/ratchet/AliceAxolotlParameters.java b/src/main/java/org/whispersystems/libaxolotl/ratchet/AliceAxolotlParameters.java
new file mode 100644
index 00000000..13c995e9
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/ratchet/AliceAxolotlParameters.java
@@ -0,0 +1,109 @@
+package org.whispersystems.libaxolotl.ratchet;
+
+import org.whispersystems.libaxolotl.IdentityKey;
+import org.whispersystems.libaxolotl.IdentityKeyPair;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+import org.whispersystems.libaxolotl.util.guava.Optional;
+
+public class AliceAxolotlParameters {
+
+ private final IdentityKeyPair ourIdentityKey;
+ private final ECKeyPair ourBaseKey;
+
+ private final IdentityKey theirIdentityKey;
+ private final ECPublicKey theirSignedPreKey;
+ private final Optional<ECPublicKey> theirOneTimePreKey;
+ private final ECPublicKey theirRatchetKey;
+
+ private AliceAxolotlParameters(IdentityKeyPair ourIdentityKey, ECKeyPair ourBaseKey,
+ IdentityKey theirIdentityKey, ECPublicKey theirSignedPreKey,
+ ECPublicKey theirRatchetKey, Optional<ECPublicKey> theirOneTimePreKey)
+ {
+ this.ourIdentityKey = ourIdentityKey;
+ this.ourBaseKey = ourBaseKey;
+ this.theirIdentityKey = theirIdentityKey;
+ this.theirSignedPreKey = theirSignedPreKey;
+ this.theirRatchetKey = theirRatchetKey;
+ this.theirOneTimePreKey = theirOneTimePreKey;
+
+ if (ourIdentityKey == null || ourBaseKey == null || theirIdentityKey == null ||
+ theirSignedPreKey == null || theirRatchetKey == null || theirOneTimePreKey == null)
+ {
+ throw new IllegalArgumentException("Null values!");
+ }
+ }
+
+ public IdentityKeyPair getOurIdentityKey() {
+ return ourIdentityKey;
+ }
+
+ public ECKeyPair getOurBaseKey() {
+ return ourBaseKey;
+ }
+
+ public IdentityKey getTheirIdentityKey() {
+ return theirIdentityKey;
+ }
+
+ public ECPublicKey getTheirSignedPreKey() {
+ return theirSignedPreKey;
+ }
+
+ public Optional<ECPublicKey> getTheirOneTimePreKey() {
+ return theirOneTimePreKey;
+ }
+
+ public static Builder newBuilder() {
+ return new Builder();
+ }
+
+ public ECPublicKey getTheirRatchetKey() {
+ return theirRatchetKey;
+ }
+
+ public static class Builder {
+ private IdentityKeyPair ourIdentityKey;
+ private ECKeyPair ourBaseKey;
+
+ private IdentityKey theirIdentityKey;
+ private ECPublicKey theirSignedPreKey;
+ private ECPublicKey theirRatchetKey;
+ private Optional<ECPublicKey> theirOneTimePreKey;
+
+ public Builder setOurIdentityKey(IdentityKeyPair ourIdentityKey) {
+ this.ourIdentityKey = ourIdentityKey;
+ return this;
+ }
+
+ public Builder setOurBaseKey(ECKeyPair ourBaseKey) {
+ this.ourBaseKey = ourBaseKey;
+ return this;
+ }
+
+ public Builder setTheirRatchetKey(ECPublicKey theirRatchetKey) {
+ this.theirRatchetKey = theirRatchetKey;
+ return this;
+ }
+
+ public Builder setTheirIdentityKey(IdentityKey theirIdentityKey) {
+ this.theirIdentityKey = theirIdentityKey;
+ return this;
+ }
+
+ public Builder setTheirSignedPreKey(ECPublicKey theirSignedPreKey) {
+ this.theirSignedPreKey = theirSignedPreKey;
+ return this;
+ }
+
+ public Builder setTheirOneTimePreKey(Optional<ECPublicKey> theirOneTimePreKey) {
+ this.theirOneTimePreKey = theirOneTimePreKey;
+ return this;
+ }
+
+ public AliceAxolotlParameters create() {
+ return new AliceAxolotlParameters(ourIdentityKey, ourBaseKey, theirIdentityKey,
+ theirSignedPreKey, theirRatchetKey, theirOneTimePreKey);
+ }
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/ratchet/BobAxolotlParameters.java b/src/main/java/org/whispersystems/libaxolotl/ratchet/BobAxolotlParameters.java
new file mode 100644
index 00000000..27116a8b
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/ratchet/BobAxolotlParameters.java
@@ -0,0 +1,109 @@
+package org.whispersystems.libaxolotl.ratchet;
+
+import org.whispersystems.libaxolotl.IdentityKey;
+import org.whispersystems.libaxolotl.IdentityKeyPair;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+import org.whispersystems.libaxolotl.util.guava.Optional;
+
+public class BobAxolotlParameters {
+
+ private final IdentityKeyPair ourIdentityKey;
+ private final ECKeyPair ourSignedPreKey;
+ private final Optional<ECKeyPair> ourOneTimePreKey;
+ private final ECKeyPair ourRatchetKey;
+
+ private final IdentityKey theirIdentityKey;
+ private final ECPublicKey theirBaseKey;
+
+ BobAxolotlParameters(IdentityKeyPair ourIdentityKey, ECKeyPair ourSignedPreKey,
+ ECKeyPair ourRatchetKey, Optional<ECKeyPair> ourOneTimePreKey,
+ IdentityKey theirIdentityKey, ECPublicKey theirBaseKey)
+ {
+ this.ourIdentityKey = ourIdentityKey;
+ this.ourSignedPreKey = ourSignedPreKey;
+ this.ourRatchetKey = ourRatchetKey;
+ this.ourOneTimePreKey = ourOneTimePreKey;
+ this.theirIdentityKey = theirIdentityKey;
+ this.theirBaseKey = theirBaseKey;
+
+ if (ourIdentityKey == null || ourSignedPreKey == null || ourRatchetKey == null ||
+ ourOneTimePreKey == null || theirIdentityKey == null || theirBaseKey == null)
+ {
+ throw new IllegalArgumentException("Null value!");
+ }
+ }
+
+ public IdentityKeyPair getOurIdentityKey() {
+ return ourIdentityKey;
+ }
+
+ public ECKeyPair getOurSignedPreKey() {
+ return ourSignedPreKey;
+ }
+
+ public Optional<ECKeyPair> getOurOneTimePreKey() {
+ return ourOneTimePreKey;
+ }
+
+ public IdentityKey getTheirIdentityKey() {
+ return theirIdentityKey;
+ }
+
+ public ECPublicKey getTheirBaseKey() {
+ return theirBaseKey;
+ }
+
+ public static Builder newBuilder() {
+ return new Builder();
+ }
+
+ public ECKeyPair getOurRatchetKey() {
+ return ourRatchetKey;
+ }
+
+ public static class Builder {
+ private IdentityKeyPair ourIdentityKey;
+ private ECKeyPair ourSignedPreKey;
+ private Optional<ECKeyPair> ourOneTimePreKey;
+ private ECKeyPair ourRatchetKey;
+
+ private IdentityKey theirIdentityKey;
+ private ECPublicKey theirBaseKey;
+
+ public Builder setOurIdentityKey(IdentityKeyPair ourIdentityKey) {
+ this.ourIdentityKey = ourIdentityKey;
+ return this;
+ }
+
+ public Builder setOurSignedPreKey(ECKeyPair ourSignedPreKey) {
+ this.ourSignedPreKey = ourSignedPreKey;
+ return this;
+ }
+
+ public Builder setOurOneTimePreKey(Optional<ECKeyPair> ourOneTimePreKey) {
+ this.ourOneTimePreKey = ourOneTimePreKey;
+ return this;
+ }
+
+ public Builder setTheirIdentityKey(IdentityKey theirIdentityKey) {
+ this.theirIdentityKey = theirIdentityKey;
+ return this;
+ }
+
+ public Builder setTheirBaseKey(ECPublicKey theirBaseKey) {
+ this.theirBaseKey = theirBaseKey;
+ return this;
+ }
+
+ public Builder setOurRatchetKey(ECKeyPair ourRatchetKey) {
+ this.ourRatchetKey = ourRatchetKey;
+ return this;
+ }
+
+ public BobAxolotlParameters create() {
+ return new BobAxolotlParameters(ourIdentityKey, ourSignedPreKey, ourRatchetKey,
+ ourOneTimePreKey, theirIdentityKey, theirBaseKey);
+ }
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/ratchet/ChainKey.java b/src/main/java/org/whispersystems/libaxolotl/ratchet/ChainKey.java
new file mode 100644
index 00000000..9dd1dbee
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/ratchet/ChainKey.java
@@ -0,0 +1,75 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl.ratchet;
+
+
+import org.whispersystems.libaxolotl.kdf.DerivedMessageSecrets;
+import org.whispersystems.libaxolotl.kdf.HKDF;
+
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+
+public class ChainKey {
+
+ private static final byte[] MESSAGE_KEY_SEED = {0x01};
+ private static final byte[] CHAIN_KEY_SEED = {0x02};
+
+ private final HKDF kdf;
+ private final byte[] key;
+ private final int index;
+
+ public ChainKey(HKDF kdf, byte[] key, int index) {
+ this.kdf = kdf;
+ this.key = key;
+ this.index = index;
+ }
+
+ public byte[] getKey() {
+ return key;
+ }
+
+ public int getIndex() {
+ return index;
+ }
+
+ public ChainKey getNextChainKey() {
+ byte[] nextKey = getBaseMaterial(CHAIN_KEY_SEED);
+ return new ChainKey(kdf, nextKey, index + 1);
+ }
+
+ public MessageKeys getMessageKeys() {
+ byte[] inputKeyMaterial = getBaseMaterial(MESSAGE_KEY_SEED);
+ byte[] keyMaterialBytes = kdf.deriveSecrets(inputKeyMaterial, "WhisperMessageKeys".getBytes(), DerivedMessageSecrets.SIZE);
+ DerivedMessageSecrets keyMaterial = new DerivedMessageSecrets(keyMaterialBytes);
+
+ return new MessageKeys(keyMaterial.getCipherKey(), keyMaterial.getMacKey(), keyMaterial.getIv(), index);
+ }
+
+ private byte[] getBaseMaterial(byte[] seed) {
+ try {
+ Mac mac = Mac.getInstance("HmacSHA256");
+ mac.init(new SecretKeySpec(key, "HmacSHA256"));
+
+ return mac.doFinal(seed);
+ } catch (NoSuchAlgorithmException | InvalidKeyException e) {
+ throw new AssertionError(e);
+ }
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/ratchet/MessageKeys.java b/src/main/java/org/whispersystems/libaxolotl/ratchet/MessageKeys.java
new file mode 100644
index 00000000..95a8c7dc
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/ratchet/MessageKeys.java
@@ -0,0 +1,51 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl.ratchet;
+
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+
+public class MessageKeys {
+
+ private final SecretKeySpec cipherKey;
+ private final SecretKeySpec macKey;
+ private final IvParameterSpec iv;
+ private final int counter;
+
+ public MessageKeys(SecretKeySpec cipherKey, SecretKeySpec macKey, IvParameterSpec iv, int counter) {
+ this.cipherKey = cipherKey;
+ this.macKey = macKey;
+ this.iv = iv;
+ this.counter = counter;
+ }
+
+ public SecretKeySpec getCipherKey() {
+ return cipherKey;
+ }
+
+ public SecretKeySpec getMacKey() {
+ return macKey;
+ }
+
+ public IvParameterSpec getIv() {
+ return iv;
+ }
+
+ public int getCounter() {
+ return counter;
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/ratchet/RatchetingSession.java b/src/main/java/org/whispersystems/libaxolotl/ratchet/RatchetingSession.java
new file mode 100644
index 00000000..8c094ec0
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/ratchet/RatchetingSession.java
@@ -0,0 +1,179 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl.ratchet;
+
+import org.whispersystems.libaxolotl.InvalidKeyException;
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+import org.whispersystems.libaxolotl.kdf.HKDF;
+import org.whispersystems.libaxolotl.state.SessionState;
+import org.whispersystems.libaxolotl.util.ByteUtil;
+import org.whispersystems.libaxolotl.util.Pair;
+import org.whispersystems.libaxolotl.util.guava.Optional;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class RatchetingSession {
+
+ public static void initializeSession(SessionState sessionState,
+ int sessionVersion,
+ SymmetricAxolotlParameters parameters)
+ throws InvalidKeyException
+ {
+ if (isAlice(parameters.getOurBaseKey().getPublicKey(), parameters.getTheirBaseKey())) {
+ AliceAxolotlParameters.Builder aliceParameters = AliceAxolotlParameters.newBuilder();
+
+ aliceParameters.setOurBaseKey(parameters.getOurBaseKey())
+ .setOurIdentityKey(parameters.getOurIdentityKey())
+ .setTheirRatchetKey(parameters.getTheirRatchetKey())
+ .setTheirIdentityKey(parameters.getTheirIdentityKey())
+ .setTheirSignedPreKey(parameters.getTheirBaseKey())
+ .setTheirOneTimePreKey(Optional.<ECPublicKey>absent());
+
+ RatchetingSession.initializeSession(sessionState, sessionVersion, aliceParameters.create());
+ } else {
+ BobAxolotlParameters.Builder bobParameters = BobAxolotlParameters.newBuilder();
+
+ bobParameters.setOurIdentityKey(parameters.getOurIdentityKey())
+ .setOurRatchetKey(parameters.getOurRatchetKey())
+ .setOurSignedPreKey(parameters.getOurBaseKey())
+ .setOurOneTimePreKey(Optional.<ECKeyPair>absent())
+ .setTheirBaseKey(parameters.getTheirBaseKey())
+ .setTheirIdentityKey(parameters.getTheirIdentityKey());
+
+ RatchetingSession.initializeSession(sessionState, sessionVersion, bobParameters.create());
+ }
+ }
+
+ public static void initializeSession(SessionState sessionState,
+ int sessionVersion,
+ AliceAxolotlParameters parameters)
+ throws InvalidKeyException
+ {
+ try {
+ sessionState.setSessionVersion(sessionVersion);
+ sessionState.setRemoteIdentityKey(parameters.getTheirIdentityKey());
+ sessionState.setLocalIdentityKey(parameters.getOurIdentityKey().getPublicKey());
+
+ ECKeyPair sendingRatchetKey = Curve.generateKeyPair();
+ ByteArrayOutputStream secrets = new ByteArrayOutputStream();
+
+ if (sessionVersion >= 3) {
+ secrets.write(getDiscontinuityBytes());
+ }
+
+ secrets.write(Curve.calculateAgreement(parameters.getTheirSignedPreKey(),
+ parameters.getOurIdentityKey().getPrivateKey()));
+ secrets.write(Curve.calculateAgreement(parameters.getTheirIdentityKey().getPublicKey(),
+ parameters.getOurBaseKey().getPrivateKey()));
+ secrets.write(Curve.calculateAgreement(parameters.getTheirSignedPreKey(),
+ parameters.getOurBaseKey().getPrivateKey()));
+
+ if (sessionVersion >= 3 & parameters.getTheirOneTimePreKey().isPresent()) {
+ secrets.write(Curve.calculateAgreement(parameters.getTheirOneTimePreKey().get(),
+ parameters.getOurBaseKey().getPrivateKey()));
+ }
+
+ DerivedKeys derivedKeys = calculateDerivedKeys(sessionVersion, secrets.toByteArray());
+ Pair<RootKey, ChainKey> sendingChain = derivedKeys.getRootKey().createChain(parameters.getTheirRatchetKey(), sendingRatchetKey);
+
+ sessionState.addReceiverChain(parameters.getTheirRatchetKey(), derivedKeys.getChainKey());
+ sessionState.setSenderChain(sendingRatchetKey, sendingChain.second());
+ sessionState.setRootKey(sendingChain.first());
+ } catch (IOException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ public static void initializeSession(SessionState sessionState,
+ int sessionVersion,
+ BobAxolotlParameters parameters)
+ throws InvalidKeyException
+ {
+
+ try {
+ sessionState.setSessionVersion(sessionVersion);
+ sessionState.setRemoteIdentityKey(parameters.getTheirIdentityKey());
+ sessionState.setLocalIdentityKey(parameters.getOurIdentityKey().getPublicKey());
+
+ ByteArrayOutputStream secrets = new ByteArrayOutputStream();
+
+ if (sessionVersion >= 3) {
+ secrets.write(getDiscontinuityBytes());
+ }
+
+ secrets.write(Curve.calculateAgreement(parameters.getTheirIdentityKey().getPublicKey(),
+ parameters.getOurSignedPreKey().getPrivateKey()));
+ secrets.write(Curve.calculateAgreement(parameters.getTheirBaseKey(),
+ parameters.getOurIdentityKey().getPrivateKey()));
+ secrets.write(Curve.calculateAgreement(parameters.getTheirBaseKey(),
+ parameters.getOurSignedPreKey().getPrivateKey()));
+
+ if (sessionVersion >= 3 && parameters.getOurOneTimePreKey().isPresent()) {
+ secrets.write(Curve.calculateAgreement(parameters.getTheirBaseKey(),
+ parameters.getOurOneTimePreKey().get().getPrivateKey()));
+ }
+
+ DerivedKeys derivedKeys = calculateDerivedKeys(sessionVersion, secrets.toByteArray());
+
+ sessionState.setSenderChain(parameters.getOurRatchetKey(), derivedKeys.getChainKey());
+ sessionState.setRootKey(derivedKeys.getRootKey());
+ } catch (IOException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ private static byte[] getDiscontinuityBytes() {
+ byte[] discontinuity = new byte[32];
+ Arrays.fill(discontinuity, (byte) 0xFF);
+ return discontinuity;
+ }
+
+ private static DerivedKeys calculateDerivedKeys(int sessionVersion, byte[] masterSecret) {
+ HKDF kdf = HKDF.createFor(sessionVersion);
+ byte[] derivedSecretBytes = kdf.deriveSecrets(masterSecret, "WhisperText".getBytes(), 64);
+ byte[][] derivedSecrets = ByteUtil.split(derivedSecretBytes, 32, 32);
+
+ return new DerivedKeys(new RootKey(kdf, derivedSecrets[0]),
+ new ChainKey(kdf, derivedSecrets[1], 0));
+ }
+
+ private static boolean isAlice(ECPublicKey ourKey, ECPublicKey theirKey) {
+ return ourKey.compareTo(theirKey) < 0;
+ }
+
+ private static class DerivedKeys {
+ private final RootKey rootKey;
+ private final ChainKey chainKey;
+
+ private DerivedKeys(RootKey rootKey, ChainKey chainKey) {
+ this.rootKey = rootKey;
+ this.chainKey = chainKey;
+ }
+
+ public RootKey getRootKey() {
+ return rootKey;
+ }
+
+ public ChainKey getChainKey() {
+ return chainKey;
+ }
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/ratchet/RootKey.java b/src/main/java/org/whispersystems/libaxolotl/ratchet/RootKey.java
new file mode 100644
index 00000000..39f3a831
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/ratchet/RootKey.java
@@ -0,0 +1,54 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl.ratchet;
+
+import org.whispersystems.libaxolotl.InvalidKeyException;
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+import org.whispersystems.libaxolotl.kdf.DerivedRootSecrets;
+import org.whispersystems.libaxolotl.kdf.HKDF;
+import org.whispersystems.libaxolotl.util.ByteUtil;
+import org.whispersystems.libaxolotl.util.Pair;
+
+public class RootKey {
+
+ private final HKDF kdf;
+ private final byte[] key;
+
+ public RootKey(HKDF kdf, byte[] key) {
+ this.kdf = kdf;
+ this.key = key;
+ }
+
+ public byte[] getKeyBytes() {
+ return key;
+ }
+
+ public Pair<RootKey, ChainKey> createChain(ECPublicKey theirRatchetKey, ECKeyPair ourRatchetKey)
+ throws InvalidKeyException
+ {
+ byte[] sharedSecret = Curve.calculateAgreement(theirRatchetKey, ourRatchetKey.getPrivateKey());
+ byte[] derivedSecretBytes = kdf.deriveSecrets(sharedSecret, key, "WhisperRatchet".getBytes(), DerivedRootSecrets.SIZE);
+ DerivedRootSecrets derivedSecrets = new DerivedRootSecrets(derivedSecretBytes);
+
+ RootKey newRootKey = new RootKey(kdf, derivedSecrets.getRootKey());
+ ChainKey newChainKey = new ChainKey(kdf, derivedSecrets.getChainKey(), 0);
+
+ return new Pair<>(newRootKey, newChainKey);
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/ratchet/SymmetricAxolotlParameters.java b/src/main/java/org/whispersystems/libaxolotl/ratchet/SymmetricAxolotlParameters.java
new file mode 100644
index 00000000..7a63c45f
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/ratchet/SymmetricAxolotlParameters.java
@@ -0,0 +1,108 @@
+package org.whispersystems.libaxolotl.ratchet;
+
+import org.whispersystems.libaxolotl.IdentityKey;
+import org.whispersystems.libaxolotl.IdentityKeyPair;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+
+public class SymmetricAxolotlParameters {
+
+ private final ECKeyPair ourBaseKey;
+ private final ECKeyPair ourRatchetKey;
+ private final IdentityKeyPair ourIdentityKey;
+
+ private final ECPublicKey theirBaseKey;
+ private final ECPublicKey theirRatchetKey;
+ private final IdentityKey theirIdentityKey;
+
+ SymmetricAxolotlParameters(ECKeyPair ourBaseKey, ECKeyPair ourRatchetKey,
+ IdentityKeyPair ourIdentityKey, ECPublicKey theirBaseKey,
+ ECPublicKey theirRatchetKey, IdentityKey theirIdentityKey)
+ {
+ this.ourBaseKey = ourBaseKey;
+ this.ourRatchetKey = ourRatchetKey;
+ this.ourIdentityKey = ourIdentityKey;
+ this.theirBaseKey = theirBaseKey;
+ this.theirRatchetKey = theirRatchetKey;
+ this.theirIdentityKey = theirIdentityKey;
+
+ if (ourBaseKey == null || ourRatchetKey == null || ourIdentityKey == null ||
+ theirBaseKey == null || theirRatchetKey == null || theirIdentityKey == null)
+ {
+ throw new IllegalArgumentException("Null values!");
+ }
+ }
+
+ public ECKeyPair getOurBaseKey() {
+ return ourBaseKey;
+ }
+
+ public ECKeyPair getOurRatchetKey() {
+ return ourRatchetKey;
+ }
+
+ public IdentityKeyPair getOurIdentityKey() {
+ return ourIdentityKey;
+ }
+
+ public ECPublicKey getTheirBaseKey() {
+ return theirBaseKey;
+ }
+
+ public ECPublicKey getTheirRatchetKey() {
+ return theirRatchetKey;
+ }
+
+ public IdentityKey getTheirIdentityKey() {
+ return theirIdentityKey;
+ }
+
+ public static Builder newBuilder() {
+ return new Builder();
+ }
+
+ public static class Builder {
+ private ECKeyPair ourBaseKey;
+ private ECKeyPair ourRatchetKey;
+ private IdentityKeyPair ourIdentityKey;
+
+ private ECPublicKey theirBaseKey;
+ private ECPublicKey theirRatchetKey;
+ private IdentityKey theirIdentityKey;
+
+ public Builder setOurBaseKey(ECKeyPair ourBaseKey) {
+ this.ourBaseKey = ourBaseKey;
+ return this;
+ }
+
+ public Builder setOurRatchetKey(ECKeyPair ourRatchetKey) {
+ this.ourRatchetKey = ourRatchetKey;
+ return this;
+ }
+
+ public Builder setOurIdentityKey(IdentityKeyPair ourIdentityKey) {
+ this.ourIdentityKey = ourIdentityKey;
+ return this;
+ }
+
+ public Builder setTheirBaseKey(ECPublicKey theirBaseKey) {
+ this.theirBaseKey = theirBaseKey;
+ return this;
+ }
+
+ public Builder setTheirRatchetKey(ECPublicKey theirRatchetKey) {
+ this.theirRatchetKey = theirRatchetKey;
+ return this;
+ }
+
+ public Builder setTheirIdentityKey(IdentityKey theirIdentityKey) {
+ this.theirIdentityKey = theirIdentityKey;
+ return this;
+ }
+
+ public SymmetricAxolotlParameters create() {
+ return new SymmetricAxolotlParameters(ourBaseKey, ourRatchetKey, ourIdentityKey,
+ theirBaseKey, theirRatchetKey, theirIdentityKey);
+ }
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/state/AxolotlStore.java b/src/main/java/org/whispersystems/libaxolotl/state/AxolotlStore.java
new file mode 100644
index 00000000..2fda9a21
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/state/AxolotlStore.java
@@ -0,0 +1,6 @@
+package org.whispersystems.libaxolotl.state;
+
+public interface AxolotlStore
+ extends IdentityKeyStore, PreKeyStore, SessionStore, SignedPreKeyStore
+{
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/state/IdentityKeyStore.java b/src/main/java/org/whispersystems/libaxolotl/state/IdentityKeyStore.java
new file mode 100644
index 00000000..d2024f78
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/state/IdentityKeyStore.java
@@ -0,0 +1,57 @@
+package org.whispersystems.libaxolotl.state;
+
+import org.whispersystems.libaxolotl.IdentityKey;
+import org.whispersystems.libaxolotl.IdentityKeyPair;
+
+/**
+ * Provides an interface to identity information.
+ *
+ * @author Moxie Marlinspike
+ */
+public interface IdentityKeyStore {
+
+ /**
+ * Get the local client's identity key pair.
+ *
+ * @return The local client's persistent identity key pair.
+ */
+ public IdentityKeyPair getIdentityKeyPair();
+
+ /**
+ * Return the local client's registration ID.
+ * <p>
+ * Clients should maintain a registration ID, a random number
+ * between 1 and 16380 that's generated once at install time.
+ *
+ * @return the local client's registration ID.
+ */
+ public int getLocalRegistrationId();
+
+ /**
+ * Save a remote client's identity key
+ * <p>
+ * Store a remote client's identity key as trusted.
+ *
+ * @param recipientId The recipient ID of the remote client.
+ * @param identityKey The remote client's identity key.
+ */
+ public void saveIdentity(long recipientId, IdentityKey identityKey);
+
+
+ /**
+ * Verify a remote client's identity key.
+ * <p>
+ * Determine whether a remote client's identity is trusted. Convention is
+ * that the TextSecure protocol is 'trust on first use.' This means that
+ * an identity key is considered 'trusted' if there is no entry for the recipient
+ * in the local store, or if it matches the saved key for a recipient in the local
+ * store. Only if it mismatches an entry in the local store is it considered
+ * 'untrusted.'
+ *
+ * @param recipientId The recipient ID of the remote client.
+ * @param identityKey The identity key to verify.
+ * @return true if trusted, false if untrusted.
+ */
+ public boolean isTrustedIdentity(long recipientId, IdentityKey identityKey);
+
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/state/PreKeyBundle.java b/src/main/java/org/whispersystems/libaxolotl/state/PreKeyBundle.java
new file mode 100644
index 00000000..772bcc14
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/state/PreKeyBundle.java
@@ -0,0 +1,96 @@
+package org.whispersystems.libaxolotl.state;
+
+import org.whispersystems.libaxolotl.IdentityKey;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+
+/**
+ * A class that contains a remote PreKey and collection
+ * of associated items.
+ *
+ * @author Moxie Marlinspike
+ */
+public class PreKeyBundle {
+
+ private int registrationId;
+
+ private int deviceId;
+
+ private int preKeyId;
+ private ECPublicKey preKeyPublic;
+
+ private int signedPreKeyId;
+ private ECPublicKey signedPreKeyPublic;
+ private byte[] signedPreKeySignature;
+
+ private IdentityKey identityKey;
+
+ public PreKeyBundle(int registrationId, int deviceId, int preKeyId, ECPublicKey preKeyPublic,
+ int signedPreKeyId, ECPublicKey signedPreKeyPublic, byte[] signedPreKeySignature,
+ IdentityKey identityKey)
+ {
+ this.registrationId = registrationId;
+ this.deviceId = deviceId;
+ this.preKeyId = preKeyId;
+ this.preKeyPublic = preKeyPublic;
+ this.signedPreKeyId = signedPreKeyId;
+ this.signedPreKeyPublic = signedPreKeyPublic;
+ this.signedPreKeySignature = signedPreKeySignature;
+ this.identityKey = identityKey;
+ }
+
+ /**
+ * @return the device ID this PreKey belongs to.
+ */
+ public int getDeviceId() {
+ return deviceId;
+ }
+
+ /**
+ * @return the unique key ID for this PreKey.
+ */
+ public int getPreKeyId() {
+ return preKeyId;
+ }
+
+ /**
+ * @return the public key for this PreKey.
+ */
+ public ECPublicKey getPreKey() {
+ return preKeyPublic;
+ }
+
+ /**
+ * @return the unique key ID for this signed prekey.
+ */
+ public int getSignedPreKeyId() {
+ return signedPreKeyId;
+ }
+
+ /**
+ * @return the signed prekey for this PreKeyBundle.
+ */
+ public ECPublicKey getSignedPreKey() {
+ return signedPreKeyPublic;
+ }
+
+ /**
+ * @return the signature over the signed prekey.
+ */
+ public byte[] getSignedPreKeySignature() {
+ return signedPreKeySignature;
+ }
+
+ /**
+ * @return the {@link org.whispersystems.libaxolotl.IdentityKey} of this PreKeys owner.
+ */
+ public IdentityKey getIdentityKey() {
+ return identityKey;
+ }
+
+ /**
+ * @return the registration ID associated with this PreKey.
+ */
+ public int getRegistrationId() {
+ return registrationId;
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/state/PreKeyRecord.java b/src/main/java/org/whispersystems/libaxolotl/state/PreKeyRecord.java
new file mode 100644
index 00000000..0ea905f4
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/state/PreKeyRecord.java
@@ -0,0 +1,51 @@
+package org.whispersystems.libaxolotl.state;
+
+import com.google.protobuf.ByteString;
+
+import org.whispersystems.libaxolotl.InvalidKeyException;
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.ecc.ECPrivateKey;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+
+import java.io.IOException;
+
+import static org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure;
+
+public class PreKeyRecord {
+
+ private PreKeyRecordStructure structure;
+
+ public PreKeyRecord(int id, ECKeyPair keyPair) {
+ this.structure = PreKeyRecordStructure.newBuilder()
+ .setId(id)
+ .setPublicKey(ByteString.copyFrom(keyPair.getPublicKey()
+ .serialize()))
+ .setPrivateKey(ByteString.copyFrom(keyPair.getPrivateKey()
+ .serialize()))
+ .build();
+ }
+
+ public PreKeyRecord(byte[] serialized) throws IOException {
+ this.structure = PreKeyRecordStructure.parseFrom(serialized);
+ }
+
+ public int getId() {
+ return this.structure.getId();
+ }
+
+ public ECKeyPair getKeyPair() {
+ try {
+ ECPublicKey publicKey = Curve.decodePoint(this.structure.getPublicKey().toByteArray(), 0);
+ ECPrivateKey privateKey = Curve.decodePrivatePoint(this.structure.getPrivateKey().toByteArray());
+
+ return new ECKeyPair(publicKey, privateKey);
+ } catch (InvalidKeyException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ public byte[] serialize() {
+ return this.structure.toByteArray();
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/state/PreKeyStore.java b/src/main/java/org/whispersystems/libaxolotl/state/PreKeyStore.java
new file mode 100644
index 00000000..7dc5e626
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/state/PreKeyStore.java
@@ -0,0 +1,42 @@
+package org.whispersystems.libaxolotl.state;
+
+import org.whispersystems.libaxolotl.InvalidKeyIdException;
+
+/**
+ * An interface describing the local storage of {@link PreKeyRecord}s.
+ *
+ * @author Moxie Marlinspike
+ */
+public interface PreKeyStore {
+
+ /**
+ * Load a local PreKeyRecord.
+ *
+ * @param preKeyId the ID of the local PreKeyRecord.
+ * @return the corresponding PreKeyRecord.
+ * @throws InvalidKeyIdException when there is no corresponding PreKeyRecord.
+ */
+ public PreKeyRecord loadPreKey(int preKeyId) throws InvalidKeyIdException;
+
+ /**
+ * Store a local PreKeyRecord.
+ *
+ * @param preKeyId the ID of the PreKeyRecord to store.
+ * @param record the PreKeyRecord.
+ */
+ public void storePreKey(int preKeyId, PreKeyRecord record);
+
+ /**
+ * @param preKeyId A PreKeyRecord ID.
+ * @return true if the store has a record for the preKeyId, otherwise false.
+ */
+ public boolean containsPreKey(int preKeyId);
+
+ /**
+ * Delete a PreKeyRecord from local storage.
+ *
+ * @param preKeyId The ID of the PreKeyRecord to remove.
+ */
+ public void removePreKey(int preKeyId);
+
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/state/SessionRecord.java b/src/main/java/org/whispersystems/libaxolotl/state/SessionRecord.java
new file mode 100644
index 00000000..76c64922
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/state/SessionRecord.java
@@ -0,0 +1,117 @@
+package org.whispersystems.libaxolotl.state;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import static org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure;
+import static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure;
+
+/**
+ * A SessionRecord encapsulates the state of an ongoing session.
+ *
+ * @author Moxie Marlinspike
+ */
+public class SessionRecord {
+
+ private static final int ARCHIVED_STATES_MAX_LENGTH = 40;
+
+ private SessionState sessionState = new SessionState();
+ private LinkedList<SessionState> previousStates = new LinkedList<>();
+ private boolean fresh = false;
+
+ public SessionRecord() {
+ this.fresh = true;
+ }
+
+ public SessionRecord(SessionState sessionState) {
+ this.sessionState = sessionState;
+ this.fresh = false;
+ }
+
+ public SessionRecord(byte[] serialized) throws IOException {
+ RecordStructure record = RecordStructure.parseFrom(serialized);
+ this.sessionState = new SessionState(record.getCurrentSession());
+ this.fresh = false;
+
+ for (SessionStructure previousStructure : record.getPreviousSessionsList()) {
+ previousStates.add(new SessionState(previousStructure));
+ }
+ }
+
+ public boolean hasSessionState(int version, byte[] aliceBaseKey) {
+ if (sessionState.getSessionVersion() == version &&
+ Arrays.equals(aliceBaseKey, sessionState.getAliceBaseKey()))
+ {
+ return true;
+ }
+
+ for (SessionState state : previousStates) {
+ if (state.getSessionVersion() == version &&
+ Arrays.equals(aliceBaseKey, state.getAliceBaseKey()))
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public SessionState getSessionState() {
+ return sessionState;
+ }
+
+ /**
+ * @return the list of all currently maintained "previous" session states.
+ */
+ public List<SessionState> getPreviousSessionStates() {
+ return previousStates;
+ }
+
+
+ public boolean isFresh() {
+ return fresh;
+ }
+
+ /**
+ * Move the current {@link SessionState} into the list of "previous" session states,
+ * and replace the current {@link org.whispersystems.libaxolotl.state.SessionState}
+ * with a fresh reset instance.
+ */
+ public void archiveCurrentState() {
+ promoteState(new SessionState());
+ }
+
+ public void promoteState(SessionState promotedState) {
+ this.previousStates.addFirst(sessionState);
+ this.sessionState = promotedState;
+
+ if (previousStates.size() > ARCHIVED_STATES_MAX_LENGTH) {
+ previousStates.removeLast();
+ }
+ }
+
+ public void setState(SessionState sessionState) {
+ this.sessionState = sessionState;
+ }
+
+ /**
+ * @return a serialized version of the current SessionRecord.
+ */
+ public byte[] serialize() {
+ List<SessionStructure> previousStructures = new LinkedList<>();
+
+ for (SessionState previousState : previousStates) {
+ previousStructures.add(previousState.getStructure());
+ }
+
+ RecordStructure record = RecordStructure.newBuilder()
+ .setCurrentSession(sessionState.getStructure())
+ .addAllPreviousSessions(previousStructures)
+ .build();
+
+ return record.toByteArray();
+ }
+
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/state/SessionState.java b/src/main/java/org/whispersystems/libaxolotl/state/SessionState.java
new file mode 100644
index 00000000..9b2b1e2a
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/state/SessionState.java
@@ -0,0 +1,509 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.whispersystems.libaxolotl.state;
+
+import android.util.Log;
+
+import com.google.protobuf.ByteString;
+
+import org.whispersystems.libaxolotl.IdentityKey;
+import org.whispersystems.libaxolotl.IdentityKeyPair;
+import org.whispersystems.libaxolotl.InvalidKeyException;
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.ecc.ECPrivateKey;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+import org.whispersystems.libaxolotl.kdf.HKDF;
+import org.whispersystems.libaxolotl.ratchet.ChainKey;
+import org.whispersystems.libaxolotl.ratchet.MessageKeys;
+import org.whispersystems.libaxolotl.ratchet.RootKey;
+import org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain;
+import org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange;
+import org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey;
+import org.whispersystems.libaxolotl.util.Pair;
+import org.whispersystems.libaxolotl.util.guava.Optional;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+
+import static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure;
+
+public class SessionState {
+
+ private SessionStructure sessionStructure;
+
+ public SessionState() {
+ this.sessionStructure = SessionStructure.newBuilder().build();
+ }
+
+ public SessionState(SessionStructure sessionStructure) {
+ this.sessionStructure = sessionStructure;
+ }
+
+ public SessionState(SessionState copy) {
+ this.sessionStructure = copy.sessionStructure.toBuilder().build();
+ }
+
+ public SessionStructure getStructure() {
+ return sessionStructure;
+ }
+
+ public byte[] getAliceBaseKey() {
+ return this.sessionStructure.getAliceBaseKey().toByteArray();
+ }
+
+ public void setAliceBaseKey(byte[] aliceBaseKey) {
+ this.sessionStructure = this.sessionStructure.toBuilder()
+ .setAliceBaseKey(ByteString.copyFrom(aliceBaseKey))
+ .build();
+ }
+
+ public void setSessionVersion(int version) {
+ this.sessionStructure = this.sessionStructure.toBuilder()
+ .setSessionVersion(version)
+ .build();
+ }
+
+ public int getSessionVersion() {
+ int sessionVersion = this.sessionStructure.getSessionVersion();
+
+ if (sessionVersion == 0) return 2;
+ else return sessionVersion;
+ }
+
+ public void setRemoteIdentityKey(IdentityKey identityKey) {
+ this.sessionStructure = this.sessionStructure.toBuilder()
+ .setRemoteIdentityPublic(ByteString.copyFrom(identityKey.serialize()))
+ .build();
+ }
+
+ public void setLocalIdentityKey(IdentityKey identityKey) {
+ this.sessionStructure = this.sessionStructure.toBuilder()
+ .setLocalIdentityPublic(ByteString.copyFrom(identityKey.serialize()))
+ .build();
+ }
+
+ public IdentityKey getRemoteIdentityKey() {
+ try {
+ if (!this.sessionStructure.hasRemoteIdentityPublic()) {
+ return null;
+ }
+
+ return new IdentityKey(this.sessionStructure.getRemoteIdentityPublic().toByteArray(), 0);
+ } catch (InvalidKeyException e) {
+ Log.w("SessionRecordV2", e);
+ return null;
+ }
+ }
+
+ public IdentityKey getLocalIdentityKey() {
+ try {
+ return new IdentityKey(this.sessionStructure.getLocalIdentityPublic().toByteArray(), 0);
+ } catch (InvalidKeyException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ public int getPreviousCounter() {
+ return sessionStructure.getPreviousCounter();
+ }
+
+ public void setPreviousCounter(int previousCounter) {
+ this.sessionStructure = this.sessionStructure.toBuilder()
+ .setPreviousCounter(previousCounter)
+ .build();
+ }
+
+ public RootKey getRootKey() {
+ return new RootKey(HKDF.createFor(getSessionVersion()),
+ this.sessionStructure.getRootKey().toByteArray());
+ }
+
+ public void setRootKey(RootKey rootKey) {
+ this.sessionStructure = this.sessionStructure.toBuilder()
+ .setRootKey(ByteString.copyFrom(rootKey.getKeyBytes()))
+ .build();
+ }
+
+ public ECPublicKey getSenderRatchetKey() {
+ try {
+ return Curve.decodePoint(sessionStructure.getSenderChain().getSenderRatchetKey().toByteArray(), 0);
+ } catch (InvalidKeyException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ public ECKeyPair getSenderRatchetKeyPair() {
+ ECPublicKey publicKey = getSenderRatchetKey();
+ ECPrivateKey privateKey = Curve.decodePrivatePoint(sessionStructure.getSenderChain()
+ .getSenderRatchetKeyPrivate()
+ .toByteArray());
+
+ return new ECKeyPair(publicKey, privateKey);
+ }
+
+ public boolean hasReceiverChain(ECPublicKey senderEphemeral) {
+ return getReceiverChain(senderEphemeral) != null;
+ }
+
+ public boolean hasSenderChain() {
+ return sessionStructure.hasSenderChain();
+ }
+
+ private Pair<Chain,Integer> getReceiverChain(ECPublicKey senderEphemeral) {
+ List<Chain> receiverChains = sessionStructure.getReceiverChainsList();
+ int index = 0;
+
+ for (Chain receiverChain : receiverChains) {
+ try {
+ ECPublicKey chainSenderRatchetKey = Curve.decodePoint(receiverChain.getSenderRatchetKey().toByteArray(), 0);
+
+ if (chainSenderRatchetKey.equals(senderEphemeral)) {
+ return new Pair<>(receiverChain,index);
+ }
+ } catch (InvalidKeyException e) {
+ Log.w("SessionRecordV2", e);
+ }
+
+ index++;
+ }
+
+ return null;
+ }
+
+ public ChainKey getReceiverChainKey(ECPublicKey senderEphemeral) {
+ Pair<Chain,Integer> receiverChainAndIndex = getReceiverChain(senderEphemeral);
+ Chain receiverChain = receiverChainAndIndex.first();
+
+ if (receiverChain == null) {
+ return null;
+ } else {
+ return new ChainKey(HKDF.createFor(getSessionVersion()),
+ receiverChain.getChainKey().getKey().toByteArray(),
+ receiverChain.getChainKey().getIndex());
+ }
+ }
+
+ public void addReceiverChain(ECPublicKey senderRatchetKey, ChainKey chainKey) {
+ Chain.ChainKey chainKeyStructure = Chain.ChainKey.newBuilder()
+ .setKey(ByteString.copyFrom(chainKey.getKey()))
+ .setIndex(chainKey.getIndex())
+ .build();
+
+ Chain chain = Chain.newBuilder()
+ .setChainKey(chainKeyStructure)
+ .setSenderRatchetKey(ByteString.copyFrom(senderRatchetKey.serialize()))
+ .build();
+
+ this.sessionStructure = this.sessionStructure.toBuilder().addReceiverChains(chain).build();
+
+ if (this.sessionStructure.getReceiverChainsList().size() > 5) {
+ this.sessionStructure = this.sessionStructure.toBuilder()
+ .removeReceiverChains(0)
+ .build();
+ }
+ }
+
+ public void setSenderChain(ECKeyPair senderRatchetKeyPair, ChainKey chainKey) {
+ Chain.ChainKey chainKeyStructure = Chain.ChainKey.newBuilder()
+ .setKey(ByteString.copyFrom(chainKey.getKey()))
+ .setIndex(chainKey.getIndex())
+ .build();
+
+ Chain senderChain = Chain.newBuilder()
+ .setSenderRatchetKey(ByteString.copyFrom(senderRatchetKeyPair.getPublicKey().serialize()))
+ .setSenderRatchetKeyPrivate(ByteString.copyFrom(senderRatchetKeyPair.getPrivateKey().serialize()))
+ .setChainKey(chainKeyStructure)
+ .build();
+
+ this.sessionStructure = this.sessionStructure.toBuilder().setSenderChain(senderChain).build();
+ }
+
+ public ChainKey getSenderChainKey() {
+ Chain.ChainKey chainKeyStructure = sessionStructure.getSenderChain().getChainKey();
+ return new ChainKey(HKDF.createFor(getSessionVersion()),
+ chainKeyStructure.getKey().toByteArray(), chainKeyStructure.getIndex());
+ }
+
+
+ public void setSenderChainKey(ChainKey nextChainKey) {
+ Chain.ChainKey chainKey = Chain.ChainKey.newBuilder()
+ .setKey(ByteString.copyFrom(nextChainKey.getKey()))
+ .setIndex(nextChainKey.getIndex())
+ .build();
+
+ Chain chain = sessionStructure.getSenderChain().toBuilder()
+ .setChainKey(chainKey).build();
+
+ this.sessionStructure = this.sessionStructure.toBuilder().setSenderChain(chain).build();
+ }
+
+ public boolean hasMessageKeys(ECPublicKey senderEphemeral, int counter) {
+ Pair<Chain,Integer> chainAndIndex = getReceiverChain(senderEphemeral);
+ Chain chain = chainAndIndex.first();
+
+ if (chain == null) {
+ return false;
+ }
+
+ List<Chain.MessageKey> messageKeyList = chain.getMessageKeysList();
+
+ for (Chain.MessageKey messageKey : messageKeyList) {
+ if (messageKey.getIndex() == counter) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public MessageKeys removeMessageKeys(ECPublicKey senderEphemeral, int counter) {
+ Pair<Chain,Integer> chainAndIndex = getReceiverChain(senderEphemeral);
+ Chain chain = chainAndIndex.first();
+
+ if (chain == null) {
+ return null;
+ }
+
+ List<Chain.MessageKey> messageKeyList = new LinkedList<>(chain.getMessageKeysList());
+ Iterator<Chain.MessageKey> messageKeyIterator = messageKeyList.iterator();
+ MessageKeys result = null;
+
+ while (messageKeyIterator.hasNext()) {
+ Chain.MessageKey messageKey = messageKeyIterator.next();
+
+ if (messageKey.getIndex() == counter) {
+ result = new MessageKeys(new SecretKeySpec(messageKey.getCipherKey().toByteArray(), "AES"),
+ new SecretKeySpec(messageKey.getMacKey().toByteArray(), "HmacSHA256"),
+ new IvParameterSpec(messageKey.getIv().toByteArray()),
+ messageKey.getIndex());
+
+ messageKeyIterator.remove();
+ break;
+ }
+ }
+
+ Chain updatedChain = chain.toBuilder().clearMessageKeys()
+ .addAllMessageKeys(messageKeyList)
+ .build();
+
+ this.sessionStructure = this.sessionStructure.toBuilder()
+ .setReceiverChains(chainAndIndex.second(), updatedChain)
+ .build();
+
+ return result;
+ }
+
+ public void setMessageKeys(ECPublicKey senderEphemeral, MessageKeys messageKeys) {
+ Pair<Chain,Integer> chainAndIndex = getReceiverChain(senderEphemeral);
+ Chain chain = chainAndIndex.first();
+ Chain.MessageKey messageKeyStructure = Chain.MessageKey.newBuilder()
+ .setCipherKey(ByteString.copyFrom(messageKeys.getCipherKey().getEncoded()))
+ .setMacKey(ByteString.copyFrom(messageKeys.getMacKey().getEncoded()))
+ .setIndex(messageKeys.getCounter())
+ .setIv(ByteString.copyFrom(messageKeys.getIv().getIV()))
+ .build();
+
+ Chain updatedChain = chain.toBuilder()
+ .addMessageKeys(messageKeyStructure)
+ .build();
+
+ this.sessionStructure = this.sessionStructure.toBuilder()
+ .setReceiverChains(chainAndIndex.second(), updatedChain)
+ .build();
+ }
+
+ public void setReceiverChainKey(ECPublicKey senderEphemeral, ChainKey chainKey) {
+ Pair<Chain,Integer> chainAndIndex = getReceiverChain(senderEphemeral);
+ Chain chain = chainAndIndex.first();
+
+ Chain.ChainKey chainKeyStructure = Chain.ChainKey.newBuilder()
+ .setKey(ByteString.copyFrom(chainKey.getKey()))
+ .setIndex(chainKey.getIndex())
+ .build();
+
+ Chain updatedChain = chain.toBuilder().setChainKey(chainKeyStructure).build();
+
+ this.sessionStructure = this.sessionStructure.toBuilder()
+ .setReceiverChains(chainAndIndex.second(), updatedChain)
+ .build();
+ }
+
+ public void setPendingKeyExchange(int sequence,
+ ECKeyPair ourBaseKey,
+ ECKeyPair ourRatchetKey,
+ IdentityKeyPair ourIdentityKey)
+ {
+ PendingKeyExchange structure =
+ PendingKeyExchange.newBuilder()
+ .setSequence(sequence)
+ .setLocalBaseKey(ByteString.copyFrom(ourBaseKey.getPublicKey().serialize()))
+ .setLocalBaseKeyPrivate(ByteString.copyFrom(ourBaseKey.getPrivateKey().serialize()))
+ .setLocalRatchetKey(ByteString.copyFrom(ourRatchetKey.getPublicKey().serialize()))
+ .setLocalRatchetKeyPrivate(ByteString.copyFrom(ourRatchetKey.getPrivateKey().serialize()))
+ .setLocalIdentityKey(ByteString.copyFrom(ourIdentityKey.getPublicKey().serialize()))
+ .setLocalIdentityKeyPrivate(ByteString.copyFrom(ourIdentityKey.getPrivateKey().serialize()))
+ .build();
+
+ this.sessionStructure = this.sessionStructure.toBuilder()
+ .setPendingKeyExchange(structure)
+ .build();
+ }
+
+ public int getPendingKeyExchangeSequence() {
+ return sessionStructure.getPendingKeyExchange().getSequence();
+ }
+
+ public ECKeyPair getPendingKeyExchangeBaseKey() throws InvalidKeyException {
+ ECPublicKey publicKey = Curve.decodePoint(sessionStructure.getPendingKeyExchange()
+ .getLocalBaseKey().toByteArray(), 0);
+
+ ECPrivateKey privateKey = Curve.decodePrivatePoint(sessionStructure.getPendingKeyExchange()
+ .getLocalBaseKeyPrivate()
+ .toByteArray());
+
+ return new ECKeyPair(publicKey, privateKey);
+ }
+
+ public ECKeyPair getPendingKeyExchangeRatchetKey() throws InvalidKeyException {
+ ECPublicKey publicKey = Curve.decodePoint(sessionStructure.getPendingKeyExchange()
+ .getLocalRatchetKey().toByteArray(), 0);
+
+ ECPrivateKey privateKey = Curve.decodePrivatePoint(sessionStructure.getPendingKeyExchange()
+ .getLocalRatchetKeyPrivate()
+ .toByteArray());
+
+ return new ECKeyPair(publicKey, privateKey);
+ }
+
+ public IdentityKeyPair getPendingKeyExchangeIdentityKey() throws InvalidKeyException {
+ IdentityKey publicKey = new IdentityKey(sessionStructure.getPendingKeyExchange()
+ .getLocalIdentityKey().toByteArray(), 0);
+
+ ECPrivateKey privateKey = Curve.decodePrivatePoint(sessionStructure.getPendingKeyExchange()
+ .getLocalIdentityKeyPrivate()
+ .toByteArray());
+
+ return new IdentityKeyPair(publicKey, privateKey);
+ }
+
+ public boolean hasPendingKeyExchange() {
+ return sessionStructure.hasPendingKeyExchange();
+ }
+
+ public void setUnacknowledgedPreKeyMessage(Optional<Integer> preKeyId, int signedPreKeyId, ECPublicKey baseKey) {
+ PendingPreKey.Builder pending = PendingPreKey.newBuilder()
+ .setSignedPreKeyId(signedPreKeyId)
+ .setBaseKey(ByteString.copyFrom(baseKey.serialize()));
+
+ if (preKeyId.isPresent()) {
+ pending.setPreKeyId(preKeyId.get());
+ }
+
+ this.sessionStructure = this.sessionStructure.toBuilder()
+ .setPendingPreKey(pending.build())
+ .build();
+ }
+
+ public boolean hasUnacknowledgedPreKeyMessage() {
+ return this.sessionStructure.hasPendingPreKey();
+ }
+
+ public UnacknowledgedPreKeyMessageItems getUnacknowledgedPreKeyMessageItems() {
+ try {
+ Optional<Integer> preKeyId;
+
+ if (sessionStructure.getPendingPreKey().hasPreKeyId()) {
+ preKeyId = Optional.of(sessionStructure.getPendingPreKey().getPreKeyId());
+ } else {
+ preKeyId = Optional.absent();
+ }
+
+ return
+ new UnacknowledgedPreKeyMessageItems(preKeyId,
+ sessionStructure.getPendingPreKey().getSignedPreKeyId(),
+ Curve.decodePoint(sessionStructure.getPendingPreKey()
+ .getBaseKey()
+ .toByteArray(), 0));
+ } catch (InvalidKeyException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ public void clearUnacknowledgedPreKeyMessage() {
+ this.sessionStructure = this.sessionStructure.toBuilder()
+ .clearPendingPreKey()
+ .build();
+ }
+
+ public void setRemoteRegistrationId(int registrationId) {
+ this.sessionStructure = this.sessionStructure.toBuilder()
+ .setRemoteRegistrationId(registrationId)
+ .build();
+ }
+
+ public int getRemoteRegistrationId() {
+ return this.sessionStructure.getRemoteRegistrationId();
+ }
+
+ public void setLocalRegistrationId(int registrationId) {
+ this.sessionStructure = this.sessionStructure.toBuilder()
+ .setLocalRegistrationId(registrationId)
+ .build();
+ }
+
+ public int getLocalRegistrationId() {
+ return this.sessionStructure.getLocalRegistrationId();
+ }
+
+ public byte[] serialize() {
+ return sessionStructure.toByteArray();
+ }
+
+ public static class UnacknowledgedPreKeyMessageItems {
+ private final Optional<Integer> preKeyId;
+ private final int signedPreKeyId;
+ private final ECPublicKey baseKey;
+
+ public UnacknowledgedPreKeyMessageItems(Optional<Integer> preKeyId,
+ int signedPreKeyId,
+ ECPublicKey baseKey)
+ {
+ this.preKeyId = preKeyId;
+ this.signedPreKeyId = signedPreKeyId;
+ this.baseKey = baseKey;
+ }
+
+
+ public Optional<Integer> getPreKeyId() {
+ return preKeyId;
+ }
+
+ public int getSignedPreKeyId() {
+ return signedPreKeyId;
+ }
+
+ public ECPublicKey getBaseKey() {
+ return baseKey;
+ }
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/state/SessionStore.java b/src/main/java/org/whispersystems/libaxolotl/state/SessionStore.java
new file mode 100644
index 00000000..c5ad00b0
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/state/SessionStore.java
@@ -0,0 +1,68 @@
+package org.whispersystems.libaxolotl.state;
+
+import java.util.List;
+
+/**
+ * The interface to the durable store of session state information
+ * for remote clients.
+ *
+ * @author Moxie Marlinspike
+ */
+public interface SessionStore {
+
+ /**
+ * Returns a copy of the {@link SessionRecord} corresponding to the recipientId + deviceId tuple,
+ * or a new SessionRecord if one does not currently exist.
+ * <p>
+ * It is important that implementations return a copy of the current durable information. The
+ * returned SessionRecord may be modified, but those changes should not have an effect on the
+ * durable session state (what is returned by subsequent calls to this method) without the
+ * store method being called here first.
+ *
+ * @param recipientId The recipientID of the remote client.
+ * @param deviceId The deviceID of the remote client.
+ * @return a copy of the SessionRecord corresponding to the recipientId + deviceId tuple, or
+ * a new SessionRecord if one does not currently exist.
+ */
+ public SessionRecord loadSession(long recipientId, int deviceId);
+
+ /**
+ * Returns all known devices with active sessions for a recipient
+ *
+ * @param recipientId the recipient ID.
+ * @return all known sub-devices with active sessions.
+ */
+ public List<Integer> getSubDeviceSessions(long recipientId);
+
+ /**
+ * Commit to storage the {@link SessionRecord} for a given recipientId + deviceId tuple.
+ * @param recipientId the recipient ID of the remote client.
+ * @param deviceId the device ID of the remote client.
+ * @param record the current SessionRecord for the remote client.
+ */
+ public void storeSession(long recipientId, int deviceId, SessionRecord record);
+
+ /**
+ * Determine whether there is a committed {@link SessionRecord} for a recipientId + deviceId tuple.
+ * @param recipientId the recipient ID of the remote client.
+ * @param deviceId the device ID of the remote client.
+ * @return true if a {@link SessionRecord} exists, false otherwise.
+ */
+ public boolean containsSession(long recipientId, int deviceId);
+
+ /**
+ * Remove a {@link SessionRecord} for a recipientId + deviceId tuple.
+ *
+ * @param recipientId the recipient ID of the remote client.
+ * @param deviceId the device ID of the remote client.
+ */
+ public void deleteSession(long recipientId, int deviceId);
+
+ /**
+ * Remove the {@link SessionRecord}s corresponding to all devices of a recipientId.
+ *
+ * @param recipientId the recipient ID of the remote client.
+ */
+ public void deleteAllSessions(long recipientId);
+
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/state/SignedPreKeyRecord.java b/src/main/java/org/whispersystems/libaxolotl/state/SignedPreKeyRecord.java
new file mode 100644
index 00000000..f11f5cf1
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/state/SignedPreKeyRecord.java
@@ -0,0 +1,61 @@
+package org.whispersystems.libaxolotl.state;
+
+import com.google.protobuf.ByteString;
+
+import org.whispersystems.libaxolotl.InvalidKeyException;
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.ecc.ECPrivateKey;
+import org.whispersystems.libaxolotl.ecc.ECPublicKey;
+
+import java.io.IOException;
+
+import static org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure;
+
+public class SignedPreKeyRecord {
+
+ private SignedPreKeyRecordStructure structure;
+
+ public SignedPreKeyRecord(int id, long timestamp, ECKeyPair keyPair, byte[] signature) {
+ this.structure = SignedPreKeyRecordStructure.newBuilder()
+ .setId(id)
+ .setPublicKey(ByteString.copyFrom(keyPair.getPublicKey()
+ .serialize()))
+ .setPrivateKey(ByteString.copyFrom(keyPair.getPrivateKey()
+ .serialize()))
+ .setSignature(ByteString.copyFrom(signature))
+ .setTimestamp(timestamp)
+ .build();
+ }
+
+ public SignedPreKeyRecord(byte[] serialized) throws IOException {
+ this.structure = SignedPreKeyRecordStructure.parseFrom(serialized);
+ }
+
+ public int getId() {
+ return this.structure.getId();
+ }
+
+ public long getTimestamp() {
+ return this.structure.getTimestamp();
+ }
+
+ public ECKeyPair getKeyPair() {
+ try {
+ ECPublicKey publicKey = Curve.decodePoint(this.structure.getPublicKey().toByteArray(), 0);
+ ECPrivateKey privateKey = Curve.decodePrivatePoint(this.structure.getPrivateKey().toByteArray());
+
+ return new ECKeyPair(publicKey, privateKey);
+ } catch (InvalidKeyException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ public byte[] getSignature() {
+ return this.structure.getSignature().toByteArray();
+ }
+
+ public byte[] serialize() {
+ return this.structure.toByteArray();
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/state/SignedPreKeyStore.java b/src/main/java/org/whispersystems/libaxolotl/state/SignedPreKeyStore.java
new file mode 100644
index 00000000..c828bf23
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/state/SignedPreKeyStore.java
@@ -0,0 +1,47 @@
+package org.whispersystems.libaxolotl.state;
+
+import org.whispersystems.libaxolotl.InvalidKeyIdException;
+
+import java.util.List;
+
+public interface SignedPreKeyStore {
+
+
+ /**
+ * Load a local SignedPreKeyRecord.
+ *
+ * @param signedPreKeyId the ID of the local SignedPreKeyRecord.
+ * @return the corresponding SignedPreKeyRecord.
+ * @throws InvalidKeyIdException when there is no corresponding SignedPreKeyRecord.
+ */
+ public SignedPreKeyRecord loadSignedPreKey(int signedPreKeyId) throws InvalidKeyIdException;
+
+ /**
+ * Load all local SignedPreKeyRecords.
+ *
+ * @return All stored SignedPreKeyRecords.
+ */
+ public List<SignedPreKeyRecord> loadSignedPreKeys();
+
+ /**
+ * Store a local SignedPreKeyRecord.
+ *
+ * @param signedPreKeyId the ID of the SignedPreKeyRecord to store.
+ * @param record the SignedPreKeyRecord.
+ */
+ public void storeSignedPreKey(int signedPreKeyId, SignedPreKeyRecord record);
+
+ /**
+ * @param signedPreKeyId A SignedPreKeyRecord ID.
+ * @return true if the store has a record for the signedPreKeyId, otherwise false.
+ */
+ public boolean containsSignedPreKey(int signedPreKeyId);
+
+ /**
+ * Delete a SignedPreKeyRecord from local storage.
+ *
+ * @param signedPreKeyId The ID of the SignedPreKeyRecord to remove.
+ */
+ public void removeSignedPreKey(int signedPreKeyId);
+
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/state/StorageProtos.java b/src/main/java/org/whispersystems/libaxolotl/state/StorageProtos.java
new file mode 100644
index 00000000..b3e3e0e6
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/state/StorageProtos.java
@@ -0,0 +1,11779 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: LocalStorageProtocol.proto
+
+package org.whispersystems.libaxolotl.state;
+
+public final class StorageProtos {
+ private StorageProtos() {}
+ public static void registerAllExtensions(
+ com.google.protobuf.ExtensionRegistry registry) {
+ }
+ public interface SessionStructureOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional uint32 sessionVersion = 1;
+ /**
+ * <code>optional uint32 sessionVersion = 1;</code>
+ */
+ boolean hasSessionVersion();
+ /**
+ * <code>optional uint32 sessionVersion = 1;</code>
+ */
+ int getSessionVersion();
+
+ // optional bytes localIdentityPublic = 2;
+ /**
+ * <code>optional bytes localIdentityPublic = 2;</code>
+ */
+ boolean hasLocalIdentityPublic();
+ /**
+ * <code>optional bytes localIdentityPublic = 2;</code>
+ */
+ com.google.protobuf.ByteString getLocalIdentityPublic();
+
+ // optional bytes remoteIdentityPublic = 3;
+ /**
+ * <code>optional bytes remoteIdentityPublic = 3;</code>
+ */
+ boolean hasRemoteIdentityPublic();
+ /**
+ * <code>optional bytes remoteIdentityPublic = 3;</code>
+ */
+ com.google.protobuf.ByteString getRemoteIdentityPublic();
+
+ // optional bytes rootKey = 4;
+ /**
+ * <code>optional bytes rootKey = 4;</code>
+ */
+ boolean hasRootKey();
+ /**
+ * <code>optional bytes rootKey = 4;</code>
+ */
+ com.google.protobuf.ByteString getRootKey();
+
+ // optional uint32 previousCounter = 5;
+ /**
+ * <code>optional uint32 previousCounter = 5;</code>
+ */
+ boolean hasPreviousCounter();
+ /**
+ * <code>optional uint32 previousCounter = 5;</code>
+ */
+ int getPreviousCounter();
+
+ // optional .textsecure.SessionStructure.Chain senderChain = 6;
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain senderChain = 6;</code>
+ */
+ boolean hasSenderChain();
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain senderChain = 6;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain getSenderChain();
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain senderChain = 6;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.ChainOrBuilder getSenderChainOrBuilder();
+
+ // repeated .textsecure.SessionStructure.Chain receiverChains = 7;
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain>
+ getReceiverChainsList();
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain getReceiverChains(int index);
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ int getReceiverChainsCount();
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ java.util.List<? extends org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.ChainOrBuilder>
+ getReceiverChainsOrBuilderList();
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.ChainOrBuilder getReceiverChainsOrBuilder(
+ int index);
+
+ // optional .textsecure.SessionStructure.PendingKeyExchange pendingKeyExchange = 8;
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingKeyExchange pendingKeyExchange = 8;</code>
+ */
+ boolean hasPendingKeyExchange();
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingKeyExchange pendingKeyExchange = 8;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange getPendingKeyExchange();
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingKeyExchange pendingKeyExchange = 8;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchangeOrBuilder getPendingKeyExchangeOrBuilder();
+
+ // optional .textsecure.SessionStructure.PendingPreKey pendingPreKey = 9;
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingPreKey pendingPreKey = 9;</code>
+ */
+ boolean hasPendingPreKey();
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingPreKey pendingPreKey = 9;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey getPendingPreKey();
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingPreKey pendingPreKey = 9;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKeyOrBuilder getPendingPreKeyOrBuilder();
+
+ // optional uint32 remoteRegistrationId = 10;
+ /**
+ * <code>optional uint32 remoteRegistrationId = 10;</code>
+ */
+ boolean hasRemoteRegistrationId();
+ /**
+ * <code>optional uint32 remoteRegistrationId = 10;</code>
+ */
+ int getRemoteRegistrationId();
+
+ // optional uint32 localRegistrationId = 11;
+ /**
+ * <code>optional uint32 localRegistrationId = 11;</code>
+ */
+ boolean hasLocalRegistrationId();
+ /**
+ * <code>optional uint32 localRegistrationId = 11;</code>
+ */
+ int getLocalRegistrationId();
+
+ // optional bool needsRefresh = 12;
+ /**
+ * <code>optional bool needsRefresh = 12;</code>
+ */
+ boolean hasNeedsRefresh();
+ /**
+ * <code>optional bool needsRefresh = 12;</code>
+ */
+ boolean getNeedsRefresh();
+
+ // optional bytes aliceBaseKey = 13;
+ /**
+ * <code>optional bytes aliceBaseKey = 13;</code>
+ */
+ boolean hasAliceBaseKey();
+ /**
+ * <code>optional bytes aliceBaseKey = 13;</code>
+ */
+ com.google.protobuf.ByteString getAliceBaseKey();
+ }
+ /**
+ * Protobuf type {@code textsecure.SessionStructure}
+ */
+ public static final class SessionStructure extends
+ com.google.protobuf.GeneratedMessage
+ implements SessionStructureOrBuilder {
+ // Use SessionStructure.newBuilder() to construct.
+ private SessionStructure(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private SessionStructure(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final SessionStructure defaultInstance;
+ public static SessionStructure getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public SessionStructure getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private SessionStructure(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 8: {
+ bitField0_ |= 0x00000001;
+ sessionVersion_ = input.readUInt32();
+ break;
+ }
+ case 18: {
+ bitField0_ |= 0x00000002;
+ localIdentityPublic_ = input.readBytes();
+ break;
+ }
+ case 26: {
+ bitField0_ |= 0x00000004;
+ remoteIdentityPublic_ = input.readBytes();
+ break;
+ }
+ case 34: {
+ bitField0_ |= 0x00000008;
+ rootKey_ = input.readBytes();
+ break;
+ }
+ case 40: {
+ bitField0_ |= 0x00000010;
+ previousCounter_ = input.readUInt32();
+ break;
+ }
+ case 50: {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.Builder subBuilder = null;
+ if (((bitField0_ & 0x00000020) == 0x00000020)) {
+ subBuilder = senderChain_.toBuilder();
+ }
+ senderChain_ = input.readMessage(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.PARSER, extensionRegistry);
+ if (subBuilder != null) {
+ subBuilder.mergeFrom(senderChain_);
+ senderChain_ = subBuilder.buildPartial();
+ }
+ bitField0_ |= 0x00000020;
+ break;
+ }
+ case 58: {
+ if (!((mutable_bitField0_ & 0x00000040) == 0x00000040)) {
+ receiverChains_ = new java.util.ArrayList<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain>();
+ mutable_bitField0_ |= 0x00000040;
+ }
+ receiverChains_.add(input.readMessage(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.PARSER, extensionRegistry));
+ break;
+ }
+ case 66: {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.Builder subBuilder = null;
+ if (((bitField0_ & 0x00000040) == 0x00000040)) {
+ subBuilder = pendingKeyExchange_.toBuilder();
+ }
+ pendingKeyExchange_ = input.readMessage(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.PARSER, extensionRegistry);
+ if (subBuilder != null) {
+ subBuilder.mergeFrom(pendingKeyExchange_);
+ pendingKeyExchange_ = subBuilder.buildPartial();
+ }
+ bitField0_ |= 0x00000040;
+ break;
+ }
+ case 74: {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.Builder subBuilder = null;
+ if (((bitField0_ & 0x00000080) == 0x00000080)) {
+ subBuilder = pendingPreKey_.toBuilder();
+ }
+ pendingPreKey_ = input.readMessage(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.PARSER, extensionRegistry);
+ if (subBuilder != null) {
+ subBuilder.mergeFrom(pendingPreKey_);
+ pendingPreKey_ = subBuilder.buildPartial();
+ }
+ bitField0_ |= 0x00000080;
+ break;
+ }
+ case 80: {
+ bitField0_ |= 0x00000100;
+ remoteRegistrationId_ = input.readUInt32();
+ break;
+ }
+ case 88: {
+ bitField0_ |= 0x00000200;
+ localRegistrationId_ = input.readUInt32();
+ break;
+ }
+ case 96: {
+ bitField0_ |= 0x00000400;
+ needsRefresh_ = input.readBool();
+ break;
+ }
+ case 106: {
+ bitField0_ |= 0x00000800;
+ aliceBaseKey_ = input.readBytes();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ if (((mutable_bitField0_ & 0x00000040) == 0x00000040)) {
+ receiverChains_ = java.util.Collections.unmodifiableList(receiverChains_);
+ }
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.class, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<SessionStructure> PARSER =
+ new com.google.protobuf.AbstractParser<SessionStructure>() {
+ public SessionStructure parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new SessionStructure(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<SessionStructure> getParserForType() {
+ return PARSER;
+ }
+
+ public interface ChainOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional bytes senderRatchetKey = 1;
+ /**
+ * <code>optional bytes senderRatchetKey = 1;</code>
+ */
+ boolean hasSenderRatchetKey();
+ /**
+ * <code>optional bytes senderRatchetKey = 1;</code>
+ */
+ com.google.protobuf.ByteString getSenderRatchetKey();
+
+ // optional bytes senderRatchetKeyPrivate = 2;
+ /**
+ * <code>optional bytes senderRatchetKeyPrivate = 2;</code>
+ */
+ boolean hasSenderRatchetKeyPrivate();
+ /**
+ * <code>optional bytes senderRatchetKeyPrivate = 2;</code>
+ */
+ com.google.protobuf.ByteString getSenderRatchetKeyPrivate();
+
+ // optional .textsecure.SessionStructure.Chain.ChainKey chainKey = 3;
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain.ChainKey chainKey = 3;</code>
+ */
+ boolean hasChainKey();
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain.ChainKey chainKey = 3;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey getChainKey();
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain.ChainKey chainKey = 3;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKeyOrBuilder getChainKeyOrBuilder();
+
+ // repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey>
+ getMessageKeysList();
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey getMessageKeys(int index);
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ int getMessageKeysCount();
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ java.util.List<? extends org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKeyOrBuilder>
+ getMessageKeysOrBuilderList();
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKeyOrBuilder getMessageKeysOrBuilder(
+ int index);
+ }
+ /**
+ * Protobuf type {@code textsecure.SessionStructure.Chain}
+ */
+ public static final class Chain extends
+ com.google.protobuf.GeneratedMessage
+ implements ChainOrBuilder {
+ // Use Chain.newBuilder() to construct.
+ private Chain(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private Chain(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final Chain defaultInstance;
+ public static Chain getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public Chain getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private Chain(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 10: {
+ bitField0_ |= 0x00000001;
+ senderRatchetKey_ = input.readBytes();
+ break;
+ }
+ case 18: {
+ bitField0_ |= 0x00000002;
+ senderRatchetKeyPrivate_ = input.readBytes();
+ break;
+ }
+ case 26: {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.Builder subBuilder = null;
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ subBuilder = chainKey_.toBuilder();
+ }
+ chainKey_ = input.readMessage(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.PARSER, extensionRegistry);
+ if (subBuilder != null) {
+ subBuilder.mergeFrom(chainKey_);
+ chainKey_ = subBuilder.buildPartial();
+ }
+ bitField0_ |= 0x00000004;
+ break;
+ }
+ case 34: {
+ if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
+ messageKeys_ = new java.util.ArrayList<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey>();
+ mutable_bitField0_ |= 0x00000008;
+ }
+ messageKeys_.add(input.readMessage(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.PARSER, extensionRegistry));
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
+ messageKeys_ = java.util.Collections.unmodifiableList(messageKeys_);
+ }
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_Chain_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_Chain_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.class, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<Chain> PARSER =
+ new com.google.protobuf.AbstractParser<Chain>() {
+ public Chain parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new Chain(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<Chain> getParserForType() {
+ return PARSER;
+ }
+
+ public interface ChainKeyOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional uint32 index = 1;
+ /**
+ * <code>optional uint32 index = 1;</code>
+ */
+ boolean hasIndex();
+ /**
+ * <code>optional uint32 index = 1;</code>
+ */
+ int getIndex();
+
+ // optional bytes key = 2;
+ /**
+ * <code>optional bytes key = 2;</code>
+ */
+ boolean hasKey();
+ /**
+ * <code>optional bytes key = 2;</code>
+ */
+ com.google.protobuf.ByteString getKey();
+ }
+ /**
+ * Protobuf type {@code textsecure.SessionStructure.Chain.ChainKey}
+ */
+ public static final class ChainKey extends
+ com.google.protobuf.GeneratedMessage
+ implements ChainKeyOrBuilder {
+ // Use ChainKey.newBuilder() to construct.
+ private ChainKey(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private ChainKey(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final ChainKey defaultInstance;
+ public static ChainKey getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public ChainKey getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private ChainKey(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 8: {
+ bitField0_ |= 0x00000001;
+ index_ = input.readUInt32();
+ break;
+ }
+ case 18: {
+ bitField0_ |= 0x00000002;
+ key_ = input.readBytes();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_Chain_ChainKey_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_Chain_ChainKey_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.class, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<ChainKey> PARSER =
+ new com.google.protobuf.AbstractParser<ChainKey>() {
+ public ChainKey parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new ChainKey(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<ChainKey> getParserForType() {
+ return PARSER;
+ }
+
+ private int bitField0_;
+ // optional uint32 index = 1;
+ public static final int INDEX_FIELD_NUMBER = 1;
+ private int index_;
+ /**
+ * <code>optional uint32 index = 1;</code>
+ */
+ public boolean hasIndex() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 index = 1;</code>
+ */
+ public int getIndex() {
+ return index_;
+ }
+
+ // optional bytes key = 2;
+ public static final int KEY_FIELD_NUMBER = 2;
+ private com.google.protobuf.ByteString key_;
+ /**
+ * <code>optional bytes key = 2;</code>
+ */
+ public boolean hasKey() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes key = 2;</code>
+ */
+ public com.google.protobuf.ByteString getKey() {
+ return key_;
+ }
+
+ private void initFields() {
+ index_ = 0;
+ key_ = com.google.protobuf.ByteString.EMPTY;
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeUInt32(1, index_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeBytes(2, key_);
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(1, index_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(2, key_);
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.SessionStructure.Chain.ChainKey}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKeyOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_Chain_ChainKey_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_Chain_ChainKey_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.class, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ index_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ key_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_Chain_ChainKey_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey build() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey buildPartial() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey result = new org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.index_ = index_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.key_ = key_;
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey) {
+ return mergeFrom((org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey other) {
+ if (other == org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.getDefaultInstance()) return this;
+ if (other.hasIndex()) {
+ setIndex(other.getIndex());
+ }
+ if (other.hasKey()) {
+ setKey(other.getKey());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional uint32 index = 1;
+ private int index_ ;
+ /**
+ * <code>optional uint32 index = 1;</code>
+ */
+ public boolean hasIndex() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 index = 1;</code>
+ */
+ public int getIndex() {
+ return index_;
+ }
+ /**
+ * <code>optional uint32 index = 1;</code>
+ */
+ public Builder setIndex(int value) {
+ bitField0_ |= 0x00000001;
+ index_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 index = 1;</code>
+ */
+ public Builder clearIndex() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ index_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional bytes key = 2;
+ private com.google.protobuf.ByteString key_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes key = 2;</code>
+ */
+ public boolean hasKey() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes key = 2;</code>
+ */
+ public com.google.protobuf.ByteString getKey() {
+ return key_;
+ }
+ /**
+ * <code>optional bytes key = 2;</code>
+ */
+ public Builder setKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000002;
+ key_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes key = 2;</code>
+ */
+ public Builder clearKey() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ key_ = getDefaultInstance().getKey();
+ onChanged();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.SessionStructure.Chain.ChainKey)
+ }
+
+ static {
+ defaultInstance = new ChainKey(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.SessionStructure.Chain.ChainKey)
+ }
+
+ public interface MessageKeyOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional uint32 index = 1;
+ /**
+ * <code>optional uint32 index = 1;</code>
+ */
+ boolean hasIndex();
+ /**
+ * <code>optional uint32 index = 1;</code>
+ */
+ int getIndex();
+
+ // optional bytes cipherKey = 2;
+ /**
+ * <code>optional bytes cipherKey = 2;</code>
+ */
+ boolean hasCipherKey();
+ /**
+ * <code>optional bytes cipherKey = 2;</code>
+ */
+ com.google.protobuf.ByteString getCipherKey();
+
+ // optional bytes macKey = 3;
+ /**
+ * <code>optional bytes macKey = 3;</code>
+ */
+ boolean hasMacKey();
+ /**
+ * <code>optional bytes macKey = 3;</code>
+ */
+ com.google.protobuf.ByteString getMacKey();
+
+ // optional bytes iv = 4;
+ /**
+ * <code>optional bytes iv = 4;</code>
+ */
+ boolean hasIv();
+ /**
+ * <code>optional bytes iv = 4;</code>
+ */
+ com.google.protobuf.ByteString getIv();
+ }
+ /**
+ * Protobuf type {@code textsecure.SessionStructure.Chain.MessageKey}
+ */
+ public static final class MessageKey extends
+ com.google.protobuf.GeneratedMessage
+ implements MessageKeyOrBuilder {
+ // Use MessageKey.newBuilder() to construct.
+ private MessageKey(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private MessageKey(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final MessageKey defaultInstance;
+ public static MessageKey getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public MessageKey getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private MessageKey(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 8: {
+ bitField0_ |= 0x00000001;
+ index_ = input.readUInt32();
+ break;
+ }
+ case 18: {
+ bitField0_ |= 0x00000002;
+ cipherKey_ = input.readBytes();
+ break;
+ }
+ case 26: {
+ bitField0_ |= 0x00000004;
+ macKey_ = input.readBytes();
+ break;
+ }
+ case 34: {
+ bitField0_ |= 0x00000008;
+ iv_ = input.readBytes();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_Chain_MessageKey_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_Chain_MessageKey_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.class, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<MessageKey> PARSER =
+ new com.google.protobuf.AbstractParser<MessageKey>() {
+ public MessageKey parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new MessageKey(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<MessageKey> getParserForType() {
+ return PARSER;
+ }
+
+ private int bitField0_;
+ // optional uint32 index = 1;
+ public static final int INDEX_FIELD_NUMBER = 1;
+ private int index_;
+ /**
+ * <code>optional uint32 index = 1;</code>
+ */
+ public boolean hasIndex() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 index = 1;</code>
+ */
+ public int getIndex() {
+ return index_;
+ }
+
+ // optional bytes cipherKey = 2;
+ public static final int CIPHERKEY_FIELD_NUMBER = 2;
+ private com.google.protobuf.ByteString cipherKey_;
+ /**
+ * <code>optional bytes cipherKey = 2;</code>
+ */
+ public boolean hasCipherKey() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes cipherKey = 2;</code>
+ */
+ public com.google.protobuf.ByteString getCipherKey() {
+ return cipherKey_;
+ }
+
+ // optional bytes macKey = 3;
+ public static final int MACKEY_FIELD_NUMBER = 3;
+ private com.google.protobuf.ByteString macKey_;
+ /**
+ * <code>optional bytes macKey = 3;</code>
+ */
+ public boolean hasMacKey() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional bytes macKey = 3;</code>
+ */
+ public com.google.protobuf.ByteString getMacKey() {
+ return macKey_;
+ }
+
+ // optional bytes iv = 4;
+ public static final int IV_FIELD_NUMBER = 4;
+ private com.google.protobuf.ByteString iv_;
+ /**
+ * <code>optional bytes iv = 4;</code>
+ */
+ public boolean hasIv() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+ * <code>optional bytes iv = 4;</code>
+ */
+ public com.google.protobuf.ByteString getIv() {
+ return iv_;
+ }
+
+ private void initFields() {
+ index_ = 0;
+ cipherKey_ = com.google.protobuf.ByteString.EMPTY;
+ macKey_ = com.google.protobuf.ByteString.EMPTY;
+ iv_ = com.google.protobuf.ByteString.EMPTY;
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeUInt32(1, index_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeBytes(2, cipherKey_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ output.writeBytes(3, macKey_);
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ output.writeBytes(4, iv_);
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(1, index_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(2, cipherKey_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(3, macKey_);
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(4, iv_);
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.SessionStructure.Chain.MessageKey}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKeyOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_Chain_MessageKey_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_Chain_MessageKey_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.class, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ index_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ cipherKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ macKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000004);
+ iv_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000008);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_Chain_MessageKey_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey build() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey buildPartial() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey result = new org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.index_ = index_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.cipherKey_ = cipherKey_;
+ if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+ to_bitField0_ |= 0x00000004;
+ }
+ result.macKey_ = macKey_;
+ if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+ to_bitField0_ |= 0x00000008;
+ }
+ result.iv_ = iv_;
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey) {
+ return mergeFrom((org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey other) {
+ if (other == org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.getDefaultInstance()) return this;
+ if (other.hasIndex()) {
+ setIndex(other.getIndex());
+ }
+ if (other.hasCipherKey()) {
+ setCipherKey(other.getCipherKey());
+ }
+ if (other.hasMacKey()) {
+ setMacKey(other.getMacKey());
+ }
+ if (other.hasIv()) {
+ setIv(other.getIv());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional uint32 index = 1;
+ private int index_ ;
+ /**
+ * <code>optional uint32 index = 1;</code>
+ */
+ public boolean hasIndex() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 index = 1;</code>
+ */
+ public int getIndex() {
+ return index_;
+ }
+ /**
+ * <code>optional uint32 index = 1;</code>
+ */
+ public Builder setIndex(int value) {
+ bitField0_ |= 0x00000001;
+ index_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 index = 1;</code>
+ */
+ public Builder clearIndex() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ index_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional bytes cipherKey = 2;
+ private com.google.protobuf.ByteString cipherKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes cipherKey = 2;</code>
+ */
+ public boolean hasCipherKey() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes cipherKey = 2;</code>
+ */
+ public com.google.protobuf.ByteString getCipherKey() {
+ return cipherKey_;
+ }
+ /**
+ * <code>optional bytes cipherKey = 2;</code>
+ */
+ public Builder setCipherKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000002;
+ cipherKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes cipherKey = 2;</code>
+ */
+ public Builder clearCipherKey() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ cipherKey_ = getDefaultInstance().getCipherKey();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes macKey = 3;
+ private com.google.protobuf.ByteString macKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes macKey = 3;</code>
+ */
+ public boolean hasMacKey() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional bytes macKey = 3;</code>
+ */
+ public com.google.protobuf.ByteString getMacKey() {
+ return macKey_;
+ }
+ /**
+ * <code>optional bytes macKey = 3;</code>
+ */
+ public Builder setMacKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000004;
+ macKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes macKey = 3;</code>
+ */
+ public Builder clearMacKey() {
+ bitField0_ = (bitField0_ & ~0x00000004);
+ macKey_ = getDefaultInstance().getMacKey();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes iv = 4;
+ private com.google.protobuf.ByteString iv_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes iv = 4;</code>
+ */
+ public boolean hasIv() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+ * <code>optional bytes iv = 4;</code>
+ */
+ public com.google.protobuf.ByteString getIv() {
+ return iv_;
+ }
+ /**
+ * <code>optional bytes iv = 4;</code>
+ */
+ public Builder setIv(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000008;
+ iv_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes iv = 4;</code>
+ */
+ public Builder clearIv() {
+ bitField0_ = (bitField0_ & ~0x00000008);
+ iv_ = getDefaultInstance().getIv();
+ onChanged();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.SessionStructure.Chain.MessageKey)
+ }
+
+ static {
+ defaultInstance = new MessageKey(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.SessionStructure.Chain.MessageKey)
+ }
+
+ private int bitField0_;
+ // optional bytes senderRatchetKey = 1;
+ public static final int SENDERRATCHETKEY_FIELD_NUMBER = 1;
+ private com.google.protobuf.ByteString senderRatchetKey_;
+ /**
+ * <code>optional bytes senderRatchetKey = 1;</code>
+ */
+ public boolean hasSenderRatchetKey() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional bytes senderRatchetKey = 1;</code>
+ */
+ public com.google.protobuf.ByteString getSenderRatchetKey() {
+ return senderRatchetKey_;
+ }
+
+ // optional bytes senderRatchetKeyPrivate = 2;
+ public static final int SENDERRATCHETKEYPRIVATE_FIELD_NUMBER = 2;
+ private com.google.protobuf.ByteString senderRatchetKeyPrivate_;
+ /**
+ * <code>optional bytes senderRatchetKeyPrivate = 2;</code>
+ */
+ public boolean hasSenderRatchetKeyPrivate() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes senderRatchetKeyPrivate = 2;</code>
+ */
+ public com.google.protobuf.ByteString getSenderRatchetKeyPrivate() {
+ return senderRatchetKeyPrivate_;
+ }
+
+ // optional .textsecure.SessionStructure.Chain.ChainKey chainKey = 3;
+ public static final int CHAINKEY_FIELD_NUMBER = 3;
+ private org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey chainKey_;
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain.ChainKey chainKey = 3;</code>
+ */
+ public boolean hasChainKey() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain.ChainKey chainKey = 3;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey getChainKey() {
+ return chainKey_;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain.ChainKey chainKey = 3;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKeyOrBuilder getChainKeyOrBuilder() {
+ return chainKey_;
+ }
+
+ // repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;
+ public static final int MESSAGEKEYS_FIELD_NUMBER = 4;
+ private java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey> messageKeys_;
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey> getMessageKeysList() {
+ return messageKeys_;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public java.util.List<? extends org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKeyOrBuilder>
+ getMessageKeysOrBuilderList() {
+ return messageKeys_;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public int getMessageKeysCount() {
+ return messageKeys_.size();
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey getMessageKeys(int index) {
+ return messageKeys_.get(index);
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKeyOrBuilder getMessageKeysOrBuilder(
+ int index) {
+ return messageKeys_.get(index);
+ }
+
+ private void initFields() {
+ senderRatchetKey_ = com.google.protobuf.ByteString.EMPTY;
+ senderRatchetKeyPrivate_ = com.google.protobuf.ByteString.EMPTY;
+ chainKey_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.getDefaultInstance();
+ messageKeys_ = java.util.Collections.emptyList();
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeBytes(1, senderRatchetKey_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeBytes(2, senderRatchetKeyPrivate_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ output.writeMessage(3, chainKey_);
+ }
+ for (int i = 0; i < messageKeys_.size(); i++) {
+ output.writeMessage(4, messageKeys_.get(i));
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(1, senderRatchetKey_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(2, senderRatchetKeyPrivate_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeMessageSize(3, chainKey_);
+ }
+ for (int i = 0; i < messageKeys_.size(); i++) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeMessageSize(4, messageKeys_.get(i));
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.SessionStructure.Chain}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.ChainOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_Chain_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_Chain_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.class, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ getChainKeyFieldBuilder();
+ getMessageKeysFieldBuilder();
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ senderRatchetKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ senderRatchetKeyPrivate_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ if (chainKeyBuilder_ == null) {
+ chainKey_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.getDefaultInstance();
+ } else {
+ chainKeyBuilder_.clear();
+ }
+ bitField0_ = (bitField0_ & ~0x00000004);
+ if (messageKeysBuilder_ == null) {
+ messageKeys_ = java.util.Collections.emptyList();
+ bitField0_ = (bitField0_ & ~0x00000008);
+ } else {
+ messageKeysBuilder_.clear();
+ }
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_Chain_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain build() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain buildPartial() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain result = new org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.senderRatchetKey_ = senderRatchetKey_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.senderRatchetKeyPrivate_ = senderRatchetKeyPrivate_;
+ if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+ to_bitField0_ |= 0x00000004;
+ }
+ if (chainKeyBuilder_ == null) {
+ result.chainKey_ = chainKey_;
+ } else {
+ result.chainKey_ = chainKeyBuilder_.build();
+ }
+ if (messageKeysBuilder_ == null) {
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ messageKeys_ = java.util.Collections.unmodifiableList(messageKeys_);
+ bitField0_ = (bitField0_ & ~0x00000008);
+ }
+ result.messageKeys_ = messageKeys_;
+ } else {
+ result.messageKeys_ = messageKeysBuilder_.build();
+ }
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain) {
+ return mergeFrom((org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain other) {
+ if (other == org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.getDefaultInstance()) return this;
+ if (other.hasSenderRatchetKey()) {
+ setSenderRatchetKey(other.getSenderRatchetKey());
+ }
+ if (other.hasSenderRatchetKeyPrivate()) {
+ setSenderRatchetKeyPrivate(other.getSenderRatchetKeyPrivate());
+ }
+ if (other.hasChainKey()) {
+ mergeChainKey(other.getChainKey());
+ }
+ if (messageKeysBuilder_ == null) {
+ if (!other.messageKeys_.isEmpty()) {
+ if (messageKeys_.isEmpty()) {
+ messageKeys_ = other.messageKeys_;
+ bitField0_ = (bitField0_ & ~0x00000008);
+ } else {
+ ensureMessageKeysIsMutable();
+ messageKeys_.addAll(other.messageKeys_);
+ }
+ onChanged();
+ }
+ } else {
+ if (!other.messageKeys_.isEmpty()) {
+ if (messageKeysBuilder_.isEmpty()) {
+ messageKeysBuilder_.dispose();
+ messageKeysBuilder_ = null;
+ messageKeys_ = other.messageKeys_;
+ bitField0_ = (bitField0_ & ~0x00000008);
+ messageKeysBuilder_ =
+ com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
+ getMessageKeysFieldBuilder() : null;
+ } else {
+ messageKeysBuilder_.addAllMessages(other.messageKeys_);
+ }
+ }
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional bytes senderRatchetKey = 1;
+ private com.google.protobuf.ByteString senderRatchetKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes senderRatchetKey = 1;</code>
+ */
+ public boolean hasSenderRatchetKey() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional bytes senderRatchetKey = 1;</code>
+ */
+ public com.google.protobuf.ByteString getSenderRatchetKey() {
+ return senderRatchetKey_;
+ }
+ /**
+ * <code>optional bytes senderRatchetKey = 1;</code>
+ */
+ public Builder setSenderRatchetKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000001;
+ senderRatchetKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes senderRatchetKey = 1;</code>
+ */
+ public Builder clearSenderRatchetKey() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ senderRatchetKey_ = getDefaultInstance().getSenderRatchetKey();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes senderRatchetKeyPrivate = 2;
+ private com.google.protobuf.ByteString senderRatchetKeyPrivate_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes senderRatchetKeyPrivate = 2;</code>
+ */
+ public boolean hasSenderRatchetKeyPrivate() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes senderRatchetKeyPrivate = 2;</code>
+ */
+ public com.google.protobuf.ByteString getSenderRatchetKeyPrivate() {
+ return senderRatchetKeyPrivate_;
+ }
+ /**
+ * <code>optional bytes senderRatchetKeyPrivate = 2;</code>
+ */
+ public Builder setSenderRatchetKeyPrivate(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000002;
+ senderRatchetKeyPrivate_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes senderRatchetKeyPrivate = 2;</code>
+ */
+ public Builder clearSenderRatchetKeyPrivate() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ senderRatchetKeyPrivate_ = getDefaultInstance().getSenderRatchetKeyPrivate();
+ onChanged();
+ return this;
+ }
+
+ // optional .textsecure.SessionStructure.Chain.ChainKey chainKey = 3;
+ private org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey chainKey_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.getDefaultInstance();
+ private com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKeyOrBuilder> chainKeyBuilder_;
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain.ChainKey chainKey = 3;</code>
+ */
+ public boolean hasChainKey() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain.ChainKey chainKey = 3;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey getChainKey() {
+ if (chainKeyBuilder_ == null) {
+ return chainKey_;
+ } else {
+ return chainKeyBuilder_.getMessage();
+ }
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain.ChainKey chainKey = 3;</code>
+ */
+ public Builder setChainKey(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey value) {
+ if (chainKeyBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ chainKey_ = value;
+ onChanged();
+ } else {
+ chainKeyBuilder_.setMessage(value);
+ }
+ bitField0_ |= 0x00000004;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain.ChainKey chainKey = 3;</code>
+ */
+ public Builder setChainKey(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.Builder builderForValue) {
+ if (chainKeyBuilder_ == null) {
+ chainKey_ = builderForValue.build();
+ onChanged();
+ } else {
+ chainKeyBuilder_.setMessage(builderForValue.build());
+ }
+ bitField0_ |= 0x00000004;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain.ChainKey chainKey = 3;</code>
+ */
+ public Builder mergeChainKey(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey value) {
+ if (chainKeyBuilder_ == null) {
+ if (((bitField0_ & 0x00000004) == 0x00000004) &&
+ chainKey_ != org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.getDefaultInstance()) {
+ chainKey_ =
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.newBuilder(chainKey_).mergeFrom(value).buildPartial();
+ } else {
+ chainKey_ = value;
+ }
+ onChanged();
+ } else {
+ chainKeyBuilder_.mergeFrom(value);
+ }
+ bitField0_ |= 0x00000004;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain.ChainKey chainKey = 3;</code>
+ */
+ public Builder clearChainKey() {
+ if (chainKeyBuilder_ == null) {
+ chainKey_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.getDefaultInstance();
+ onChanged();
+ } else {
+ chainKeyBuilder_.clear();
+ }
+ bitField0_ = (bitField0_ & ~0x00000004);
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain.ChainKey chainKey = 3;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.Builder getChainKeyBuilder() {
+ bitField0_ |= 0x00000004;
+ onChanged();
+ return getChainKeyFieldBuilder().getBuilder();
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain.ChainKey chainKey = 3;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKeyOrBuilder getChainKeyOrBuilder() {
+ if (chainKeyBuilder_ != null) {
+ return chainKeyBuilder_.getMessageOrBuilder();
+ } else {
+ return chainKey_;
+ }
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain.ChainKey chainKey = 3;</code>
+ */
+ private com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKeyOrBuilder>
+ getChainKeyFieldBuilder() {
+ if (chainKeyBuilder_ == null) {
+ chainKeyBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKey.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.ChainKeyOrBuilder>(
+ chainKey_,
+ getParentForChildren(),
+ isClean());
+ chainKey_ = null;
+ }
+ return chainKeyBuilder_;
+ }
+
+ // repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;
+ private java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey> messageKeys_ =
+ java.util.Collections.emptyList();
+ private void ensureMessageKeysIsMutable() {
+ if (!((bitField0_ & 0x00000008) == 0x00000008)) {
+ messageKeys_ = new java.util.ArrayList<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey>(messageKeys_);
+ bitField0_ |= 0x00000008;
+ }
+ }
+
+ private com.google.protobuf.RepeatedFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKeyOrBuilder> messageKeysBuilder_;
+
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey> getMessageKeysList() {
+ if (messageKeysBuilder_ == null) {
+ return java.util.Collections.unmodifiableList(messageKeys_);
+ } else {
+ return messageKeysBuilder_.getMessageList();
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public int getMessageKeysCount() {
+ if (messageKeysBuilder_ == null) {
+ return messageKeys_.size();
+ } else {
+ return messageKeysBuilder_.getCount();
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey getMessageKeys(int index) {
+ if (messageKeysBuilder_ == null) {
+ return messageKeys_.get(index);
+ } else {
+ return messageKeysBuilder_.getMessage(index);
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public Builder setMessageKeys(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey value) {
+ if (messageKeysBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureMessageKeysIsMutable();
+ messageKeys_.set(index, value);
+ onChanged();
+ } else {
+ messageKeysBuilder_.setMessage(index, value);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public Builder setMessageKeys(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.Builder builderForValue) {
+ if (messageKeysBuilder_ == null) {
+ ensureMessageKeysIsMutable();
+ messageKeys_.set(index, builderForValue.build());
+ onChanged();
+ } else {
+ messageKeysBuilder_.setMessage(index, builderForValue.build());
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public Builder addMessageKeys(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey value) {
+ if (messageKeysBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureMessageKeysIsMutable();
+ messageKeys_.add(value);
+ onChanged();
+ } else {
+ messageKeysBuilder_.addMessage(value);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public Builder addMessageKeys(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey value) {
+ if (messageKeysBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureMessageKeysIsMutable();
+ messageKeys_.add(index, value);
+ onChanged();
+ } else {
+ messageKeysBuilder_.addMessage(index, value);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public Builder addMessageKeys(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.Builder builderForValue) {
+ if (messageKeysBuilder_ == null) {
+ ensureMessageKeysIsMutable();
+ messageKeys_.add(builderForValue.build());
+ onChanged();
+ } else {
+ messageKeysBuilder_.addMessage(builderForValue.build());
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public Builder addMessageKeys(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.Builder builderForValue) {
+ if (messageKeysBuilder_ == null) {
+ ensureMessageKeysIsMutable();
+ messageKeys_.add(index, builderForValue.build());
+ onChanged();
+ } else {
+ messageKeysBuilder_.addMessage(index, builderForValue.build());
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public Builder addAllMessageKeys(
+ java.lang.Iterable<? extends org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey> values) {
+ if (messageKeysBuilder_ == null) {
+ ensureMessageKeysIsMutable();
+ super.addAll(values, messageKeys_);
+ onChanged();
+ } else {
+ messageKeysBuilder_.addAllMessages(values);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public Builder clearMessageKeys() {
+ if (messageKeysBuilder_ == null) {
+ messageKeys_ = java.util.Collections.emptyList();
+ bitField0_ = (bitField0_ & ~0x00000008);
+ onChanged();
+ } else {
+ messageKeysBuilder_.clear();
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public Builder removeMessageKeys(int index) {
+ if (messageKeysBuilder_ == null) {
+ ensureMessageKeysIsMutable();
+ messageKeys_.remove(index);
+ onChanged();
+ } else {
+ messageKeysBuilder_.remove(index);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.Builder getMessageKeysBuilder(
+ int index) {
+ return getMessageKeysFieldBuilder().getBuilder(index);
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKeyOrBuilder getMessageKeysOrBuilder(
+ int index) {
+ if (messageKeysBuilder_ == null) {
+ return messageKeys_.get(index); } else {
+ return messageKeysBuilder_.getMessageOrBuilder(index);
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public java.util.List<? extends org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKeyOrBuilder>
+ getMessageKeysOrBuilderList() {
+ if (messageKeysBuilder_ != null) {
+ return messageKeysBuilder_.getMessageOrBuilderList();
+ } else {
+ return java.util.Collections.unmodifiableList(messageKeys_);
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.Builder addMessageKeysBuilder() {
+ return getMessageKeysFieldBuilder().addBuilder(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.getDefaultInstance());
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.Builder addMessageKeysBuilder(
+ int index) {
+ return getMessageKeysFieldBuilder().addBuilder(
+ index, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.getDefaultInstance());
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain.MessageKey messageKeys = 4;</code>
+ */
+ public java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.Builder>
+ getMessageKeysBuilderList() {
+ return getMessageKeysFieldBuilder().getBuilderList();
+ }
+ private com.google.protobuf.RepeatedFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKeyOrBuilder>
+ getMessageKeysFieldBuilder() {
+ if (messageKeysBuilder_ == null) {
+ messageKeysBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKey.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.MessageKeyOrBuilder>(
+ messageKeys_,
+ ((bitField0_ & 0x00000008) == 0x00000008),
+ getParentForChildren(),
+ isClean());
+ messageKeys_ = null;
+ }
+ return messageKeysBuilder_;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.SessionStructure.Chain)
+ }
+
+ static {
+ defaultInstance = new Chain(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.SessionStructure.Chain)
+ }
+
+ public interface PendingKeyExchangeOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional uint32 sequence = 1;
+ /**
+ * <code>optional uint32 sequence = 1;</code>
+ */
+ boolean hasSequence();
+ /**
+ * <code>optional uint32 sequence = 1;</code>
+ */
+ int getSequence();
+
+ // optional bytes localBaseKey = 2;
+ /**
+ * <code>optional bytes localBaseKey = 2;</code>
+ */
+ boolean hasLocalBaseKey();
+ /**
+ * <code>optional bytes localBaseKey = 2;</code>
+ */
+ com.google.protobuf.ByteString getLocalBaseKey();
+
+ // optional bytes localBaseKeyPrivate = 3;
+ /**
+ * <code>optional bytes localBaseKeyPrivate = 3;</code>
+ */
+ boolean hasLocalBaseKeyPrivate();
+ /**
+ * <code>optional bytes localBaseKeyPrivate = 3;</code>
+ */
+ com.google.protobuf.ByteString getLocalBaseKeyPrivate();
+
+ // optional bytes localRatchetKey = 4;
+ /**
+ * <code>optional bytes localRatchetKey = 4;</code>
+ */
+ boolean hasLocalRatchetKey();
+ /**
+ * <code>optional bytes localRatchetKey = 4;</code>
+ */
+ com.google.protobuf.ByteString getLocalRatchetKey();
+
+ // optional bytes localRatchetKeyPrivate = 5;
+ /**
+ * <code>optional bytes localRatchetKeyPrivate = 5;</code>
+ */
+ boolean hasLocalRatchetKeyPrivate();
+ /**
+ * <code>optional bytes localRatchetKeyPrivate = 5;</code>
+ */
+ com.google.protobuf.ByteString getLocalRatchetKeyPrivate();
+
+ // optional bytes localIdentityKey = 7;
+ /**
+ * <code>optional bytes localIdentityKey = 7;</code>
+ */
+ boolean hasLocalIdentityKey();
+ /**
+ * <code>optional bytes localIdentityKey = 7;</code>
+ */
+ com.google.protobuf.ByteString getLocalIdentityKey();
+
+ // optional bytes localIdentityKeyPrivate = 8;
+ /**
+ * <code>optional bytes localIdentityKeyPrivate = 8;</code>
+ */
+ boolean hasLocalIdentityKeyPrivate();
+ /**
+ * <code>optional bytes localIdentityKeyPrivate = 8;</code>
+ */
+ com.google.protobuf.ByteString getLocalIdentityKeyPrivate();
+ }
+ /**
+ * Protobuf type {@code textsecure.SessionStructure.PendingKeyExchange}
+ */
+ public static final class PendingKeyExchange extends
+ com.google.protobuf.GeneratedMessage
+ implements PendingKeyExchangeOrBuilder {
+ // Use PendingKeyExchange.newBuilder() to construct.
+ private PendingKeyExchange(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private PendingKeyExchange(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final PendingKeyExchange defaultInstance;
+ public static PendingKeyExchange getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public PendingKeyExchange getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private PendingKeyExchange(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 8: {
+ bitField0_ |= 0x00000001;
+ sequence_ = input.readUInt32();
+ break;
+ }
+ case 18: {
+ bitField0_ |= 0x00000002;
+ localBaseKey_ = input.readBytes();
+ break;
+ }
+ case 26: {
+ bitField0_ |= 0x00000004;
+ localBaseKeyPrivate_ = input.readBytes();
+ break;
+ }
+ case 34: {
+ bitField0_ |= 0x00000008;
+ localRatchetKey_ = input.readBytes();
+ break;
+ }
+ case 42: {
+ bitField0_ |= 0x00000010;
+ localRatchetKeyPrivate_ = input.readBytes();
+ break;
+ }
+ case 58: {
+ bitField0_ |= 0x00000020;
+ localIdentityKey_ = input.readBytes();
+ break;
+ }
+ case 66: {
+ bitField0_ |= 0x00000040;
+ localIdentityKeyPrivate_ = input.readBytes();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_PendingKeyExchange_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_PendingKeyExchange_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.class, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<PendingKeyExchange> PARSER =
+ new com.google.protobuf.AbstractParser<PendingKeyExchange>() {
+ public PendingKeyExchange parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new PendingKeyExchange(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<PendingKeyExchange> getParserForType() {
+ return PARSER;
+ }
+
+ private int bitField0_;
+ // optional uint32 sequence = 1;
+ public static final int SEQUENCE_FIELD_NUMBER = 1;
+ private int sequence_;
+ /**
+ * <code>optional uint32 sequence = 1;</code>
+ */
+ public boolean hasSequence() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 sequence = 1;</code>
+ */
+ public int getSequence() {
+ return sequence_;
+ }
+
+ // optional bytes localBaseKey = 2;
+ public static final int LOCALBASEKEY_FIELD_NUMBER = 2;
+ private com.google.protobuf.ByteString localBaseKey_;
+ /**
+ * <code>optional bytes localBaseKey = 2;</code>
+ */
+ public boolean hasLocalBaseKey() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes localBaseKey = 2;</code>
+ */
+ public com.google.protobuf.ByteString getLocalBaseKey() {
+ return localBaseKey_;
+ }
+
+ // optional bytes localBaseKeyPrivate = 3;
+ public static final int LOCALBASEKEYPRIVATE_FIELD_NUMBER = 3;
+ private com.google.protobuf.ByteString localBaseKeyPrivate_;
+ /**
+ * <code>optional bytes localBaseKeyPrivate = 3;</code>
+ */
+ public boolean hasLocalBaseKeyPrivate() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional bytes localBaseKeyPrivate = 3;</code>
+ */
+ public com.google.protobuf.ByteString getLocalBaseKeyPrivate() {
+ return localBaseKeyPrivate_;
+ }
+
+ // optional bytes localRatchetKey = 4;
+ public static final int LOCALRATCHETKEY_FIELD_NUMBER = 4;
+ private com.google.protobuf.ByteString localRatchetKey_;
+ /**
+ * <code>optional bytes localRatchetKey = 4;</code>
+ */
+ public boolean hasLocalRatchetKey() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+ * <code>optional bytes localRatchetKey = 4;</code>
+ */
+ public com.google.protobuf.ByteString getLocalRatchetKey() {
+ return localRatchetKey_;
+ }
+
+ // optional bytes localRatchetKeyPrivate = 5;
+ public static final int LOCALRATCHETKEYPRIVATE_FIELD_NUMBER = 5;
+ private com.google.protobuf.ByteString localRatchetKeyPrivate_;
+ /**
+ * <code>optional bytes localRatchetKeyPrivate = 5;</code>
+ */
+ public boolean hasLocalRatchetKeyPrivate() {
+ return ((bitField0_ & 0x00000010) == 0x00000010);
+ }
+ /**
+ * <code>optional bytes localRatchetKeyPrivate = 5;</code>
+ */
+ public com.google.protobuf.ByteString getLocalRatchetKeyPrivate() {
+ return localRatchetKeyPrivate_;
+ }
+
+ // optional bytes localIdentityKey = 7;
+ public static final int LOCALIDENTITYKEY_FIELD_NUMBER = 7;
+ private com.google.protobuf.ByteString localIdentityKey_;
+ /**
+ * <code>optional bytes localIdentityKey = 7;</code>
+ */
+ public boolean hasLocalIdentityKey() {
+ return ((bitField0_ & 0x00000020) == 0x00000020);
+ }
+ /**
+ * <code>optional bytes localIdentityKey = 7;</code>
+ */
+ public com.google.protobuf.ByteString getLocalIdentityKey() {
+ return localIdentityKey_;
+ }
+
+ // optional bytes localIdentityKeyPrivate = 8;
+ public static final int LOCALIDENTITYKEYPRIVATE_FIELD_NUMBER = 8;
+ private com.google.protobuf.ByteString localIdentityKeyPrivate_;
+ /**
+ * <code>optional bytes localIdentityKeyPrivate = 8;</code>
+ */
+ public boolean hasLocalIdentityKeyPrivate() {
+ return ((bitField0_ & 0x00000040) == 0x00000040);
+ }
+ /**
+ * <code>optional bytes localIdentityKeyPrivate = 8;</code>
+ */
+ public com.google.protobuf.ByteString getLocalIdentityKeyPrivate() {
+ return localIdentityKeyPrivate_;
+ }
+
+ private void initFields() {
+ sequence_ = 0;
+ localBaseKey_ = com.google.protobuf.ByteString.EMPTY;
+ localBaseKeyPrivate_ = com.google.protobuf.ByteString.EMPTY;
+ localRatchetKey_ = com.google.protobuf.ByteString.EMPTY;
+ localRatchetKeyPrivate_ = com.google.protobuf.ByteString.EMPTY;
+ localIdentityKey_ = com.google.protobuf.ByteString.EMPTY;
+ localIdentityKeyPrivate_ = com.google.protobuf.ByteString.EMPTY;
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeUInt32(1, sequence_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeBytes(2, localBaseKey_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ output.writeBytes(3, localBaseKeyPrivate_);
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ output.writeBytes(4, localRatchetKey_);
+ }
+ if (((bitField0_ & 0x00000010) == 0x00000010)) {
+ output.writeBytes(5, localRatchetKeyPrivate_);
+ }
+ if (((bitField0_ & 0x00000020) == 0x00000020)) {
+ output.writeBytes(7, localIdentityKey_);
+ }
+ if (((bitField0_ & 0x00000040) == 0x00000040)) {
+ output.writeBytes(8, localIdentityKeyPrivate_);
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(1, sequence_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(2, localBaseKey_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(3, localBaseKeyPrivate_);
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(4, localRatchetKey_);
+ }
+ if (((bitField0_ & 0x00000010) == 0x00000010)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(5, localRatchetKeyPrivate_);
+ }
+ if (((bitField0_ & 0x00000020) == 0x00000020)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(7, localIdentityKey_);
+ }
+ if (((bitField0_ & 0x00000040) == 0x00000040)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(8, localIdentityKeyPrivate_);
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.SessionStructure.PendingKeyExchange}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchangeOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_PendingKeyExchange_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_PendingKeyExchange_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.class, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ sequence_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ localBaseKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ localBaseKeyPrivate_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000004);
+ localRatchetKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000008);
+ localRatchetKeyPrivate_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000010);
+ localIdentityKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000020);
+ localIdentityKeyPrivate_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000040);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_PendingKeyExchange_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange build() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange buildPartial() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange result = new org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.sequence_ = sequence_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.localBaseKey_ = localBaseKey_;
+ if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+ to_bitField0_ |= 0x00000004;
+ }
+ result.localBaseKeyPrivate_ = localBaseKeyPrivate_;
+ if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+ to_bitField0_ |= 0x00000008;
+ }
+ result.localRatchetKey_ = localRatchetKey_;
+ if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+ to_bitField0_ |= 0x00000010;
+ }
+ result.localRatchetKeyPrivate_ = localRatchetKeyPrivate_;
+ if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
+ to_bitField0_ |= 0x00000020;
+ }
+ result.localIdentityKey_ = localIdentityKey_;
+ if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
+ to_bitField0_ |= 0x00000040;
+ }
+ result.localIdentityKeyPrivate_ = localIdentityKeyPrivate_;
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange) {
+ return mergeFrom((org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange other) {
+ if (other == org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.getDefaultInstance()) return this;
+ if (other.hasSequence()) {
+ setSequence(other.getSequence());
+ }
+ if (other.hasLocalBaseKey()) {
+ setLocalBaseKey(other.getLocalBaseKey());
+ }
+ if (other.hasLocalBaseKeyPrivate()) {
+ setLocalBaseKeyPrivate(other.getLocalBaseKeyPrivate());
+ }
+ if (other.hasLocalRatchetKey()) {
+ setLocalRatchetKey(other.getLocalRatchetKey());
+ }
+ if (other.hasLocalRatchetKeyPrivate()) {
+ setLocalRatchetKeyPrivate(other.getLocalRatchetKeyPrivate());
+ }
+ if (other.hasLocalIdentityKey()) {
+ setLocalIdentityKey(other.getLocalIdentityKey());
+ }
+ if (other.hasLocalIdentityKeyPrivate()) {
+ setLocalIdentityKeyPrivate(other.getLocalIdentityKeyPrivate());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional uint32 sequence = 1;
+ private int sequence_ ;
+ /**
+ * <code>optional uint32 sequence = 1;</code>
+ */
+ public boolean hasSequence() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 sequence = 1;</code>
+ */
+ public int getSequence() {
+ return sequence_;
+ }
+ /**
+ * <code>optional uint32 sequence = 1;</code>
+ */
+ public Builder setSequence(int value) {
+ bitField0_ |= 0x00000001;
+ sequence_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 sequence = 1;</code>
+ */
+ public Builder clearSequence() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ sequence_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional bytes localBaseKey = 2;
+ private com.google.protobuf.ByteString localBaseKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes localBaseKey = 2;</code>
+ */
+ public boolean hasLocalBaseKey() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes localBaseKey = 2;</code>
+ */
+ public com.google.protobuf.ByteString getLocalBaseKey() {
+ return localBaseKey_;
+ }
+ /**
+ * <code>optional bytes localBaseKey = 2;</code>
+ */
+ public Builder setLocalBaseKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000002;
+ localBaseKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes localBaseKey = 2;</code>
+ */
+ public Builder clearLocalBaseKey() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ localBaseKey_ = getDefaultInstance().getLocalBaseKey();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes localBaseKeyPrivate = 3;
+ private com.google.protobuf.ByteString localBaseKeyPrivate_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes localBaseKeyPrivate = 3;</code>
+ */
+ public boolean hasLocalBaseKeyPrivate() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional bytes localBaseKeyPrivate = 3;</code>
+ */
+ public com.google.protobuf.ByteString getLocalBaseKeyPrivate() {
+ return localBaseKeyPrivate_;
+ }
+ /**
+ * <code>optional bytes localBaseKeyPrivate = 3;</code>
+ */
+ public Builder setLocalBaseKeyPrivate(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000004;
+ localBaseKeyPrivate_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes localBaseKeyPrivate = 3;</code>
+ */
+ public Builder clearLocalBaseKeyPrivate() {
+ bitField0_ = (bitField0_ & ~0x00000004);
+ localBaseKeyPrivate_ = getDefaultInstance().getLocalBaseKeyPrivate();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes localRatchetKey = 4;
+ private com.google.protobuf.ByteString localRatchetKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes localRatchetKey = 4;</code>
+ */
+ public boolean hasLocalRatchetKey() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+ * <code>optional bytes localRatchetKey = 4;</code>
+ */
+ public com.google.protobuf.ByteString getLocalRatchetKey() {
+ return localRatchetKey_;
+ }
+ /**
+ * <code>optional bytes localRatchetKey = 4;</code>
+ */
+ public Builder setLocalRatchetKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000008;
+ localRatchetKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes localRatchetKey = 4;</code>
+ */
+ public Builder clearLocalRatchetKey() {
+ bitField0_ = (bitField0_ & ~0x00000008);
+ localRatchetKey_ = getDefaultInstance().getLocalRatchetKey();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes localRatchetKeyPrivate = 5;
+ private com.google.protobuf.ByteString localRatchetKeyPrivate_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes localRatchetKeyPrivate = 5;</code>
+ */
+ public boolean hasLocalRatchetKeyPrivate() {
+ return ((bitField0_ & 0x00000010) == 0x00000010);
+ }
+ /**
+ * <code>optional bytes localRatchetKeyPrivate = 5;</code>
+ */
+ public com.google.protobuf.ByteString getLocalRatchetKeyPrivate() {
+ return localRatchetKeyPrivate_;
+ }
+ /**
+ * <code>optional bytes localRatchetKeyPrivate = 5;</code>
+ */
+ public Builder setLocalRatchetKeyPrivate(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000010;
+ localRatchetKeyPrivate_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes localRatchetKeyPrivate = 5;</code>
+ */
+ public Builder clearLocalRatchetKeyPrivate() {
+ bitField0_ = (bitField0_ & ~0x00000010);
+ localRatchetKeyPrivate_ = getDefaultInstance().getLocalRatchetKeyPrivate();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes localIdentityKey = 7;
+ private com.google.protobuf.ByteString localIdentityKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes localIdentityKey = 7;</code>
+ */
+ public boolean hasLocalIdentityKey() {
+ return ((bitField0_ & 0x00000020) == 0x00000020);
+ }
+ /**
+ * <code>optional bytes localIdentityKey = 7;</code>
+ */
+ public com.google.protobuf.ByteString getLocalIdentityKey() {
+ return localIdentityKey_;
+ }
+ /**
+ * <code>optional bytes localIdentityKey = 7;</code>
+ */
+ public Builder setLocalIdentityKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000020;
+ localIdentityKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes localIdentityKey = 7;</code>
+ */
+ public Builder clearLocalIdentityKey() {
+ bitField0_ = (bitField0_ & ~0x00000020);
+ localIdentityKey_ = getDefaultInstance().getLocalIdentityKey();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes localIdentityKeyPrivate = 8;
+ private com.google.protobuf.ByteString localIdentityKeyPrivate_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes localIdentityKeyPrivate = 8;</code>
+ */
+ public boolean hasLocalIdentityKeyPrivate() {
+ return ((bitField0_ & 0x00000040) == 0x00000040);
+ }
+ /**
+ * <code>optional bytes localIdentityKeyPrivate = 8;</code>
+ */
+ public com.google.protobuf.ByteString getLocalIdentityKeyPrivate() {
+ return localIdentityKeyPrivate_;
+ }
+ /**
+ * <code>optional bytes localIdentityKeyPrivate = 8;</code>
+ */
+ public Builder setLocalIdentityKeyPrivate(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000040;
+ localIdentityKeyPrivate_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes localIdentityKeyPrivate = 8;</code>
+ */
+ public Builder clearLocalIdentityKeyPrivate() {
+ bitField0_ = (bitField0_ & ~0x00000040);
+ localIdentityKeyPrivate_ = getDefaultInstance().getLocalIdentityKeyPrivate();
+ onChanged();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.SessionStructure.PendingKeyExchange)
+ }
+
+ static {
+ defaultInstance = new PendingKeyExchange(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.SessionStructure.PendingKeyExchange)
+ }
+
+ public interface PendingPreKeyOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional uint32 preKeyId = 1;
+ /**
+ * <code>optional uint32 preKeyId = 1;</code>
+ */
+ boolean hasPreKeyId();
+ /**
+ * <code>optional uint32 preKeyId = 1;</code>
+ */
+ int getPreKeyId();
+
+ // optional int32 signedPreKeyId = 3;
+ /**
+ * <code>optional int32 signedPreKeyId = 3;</code>
+ */
+ boolean hasSignedPreKeyId();
+ /**
+ * <code>optional int32 signedPreKeyId = 3;</code>
+ */
+ int getSignedPreKeyId();
+
+ // optional bytes baseKey = 2;
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ boolean hasBaseKey();
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ com.google.protobuf.ByteString getBaseKey();
+ }
+ /**
+ * Protobuf type {@code textsecure.SessionStructure.PendingPreKey}
+ */
+ public static final class PendingPreKey extends
+ com.google.protobuf.GeneratedMessage
+ implements PendingPreKeyOrBuilder {
+ // Use PendingPreKey.newBuilder() to construct.
+ private PendingPreKey(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private PendingPreKey(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final PendingPreKey defaultInstance;
+ public static PendingPreKey getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public PendingPreKey getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private PendingPreKey(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 8: {
+ bitField0_ |= 0x00000001;
+ preKeyId_ = input.readUInt32();
+ break;
+ }
+ case 18: {
+ bitField0_ |= 0x00000004;
+ baseKey_ = input.readBytes();
+ break;
+ }
+ case 24: {
+ bitField0_ |= 0x00000002;
+ signedPreKeyId_ = input.readInt32();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_PendingPreKey_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_PendingPreKey_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.class, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<PendingPreKey> PARSER =
+ new com.google.protobuf.AbstractParser<PendingPreKey>() {
+ public PendingPreKey parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new PendingPreKey(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<PendingPreKey> getParserForType() {
+ return PARSER;
+ }
+
+ private int bitField0_;
+ // optional uint32 preKeyId = 1;
+ public static final int PREKEYID_FIELD_NUMBER = 1;
+ private int preKeyId_;
+ /**
+ * <code>optional uint32 preKeyId = 1;</code>
+ */
+ public boolean hasPreKeyId() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 preKeyId = 1;</code>
+ */
+ public int getPreKeyId() {
+ return preKeyId_;
+ }
+
+ // optional int32 signedPreKeyId = 3;
+ public static final int SIGNEDPREKEYID_FIELD_NUMBER = 3;
+ private int signedPreKeyId_;
+ /**
+ * <code>optional int32 signedPreKeyId = 3;</code>
+ */
+ public boolean hasSignedPreKeyId() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional int32 signedPreKeyId = 3;</code>
+ */
+ public int getSignedPreKeyId() {
+ return signedPreKeyId_;
+ }
+
+ // optional bytes baseKey = 2;
+ public static final int BASEKEY_FIELD_NUMBER = 2;
+ private com.google.protobuf.ByteString baseKey_;
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ public boolean hasBaseKey() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ public com.google.protobuf.ByteString getBaseKey() {
+ return baseKey_;
+ }
+
+ private void initFields() {
+ preKeyId_ = 0;
+ signedPreKeyId_ = 0;
+ baseKey_ = com.google.protobuf.ByteString.EMPTY;
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeUInt32(1, preKeyId_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ output.writeBytes(2, baseKey_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeInt32(3, signedPreKeyId_);
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(1, preKeyId_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(2, baseKey_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeInt32Size(3, signedPreKeyId_);
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.SessionStructure.PendingPreKey}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKeyOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_PendingPreKey_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_PendingPreKey_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.class, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ preKeyId_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ signedPreKeyId_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ baseKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000004);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_PendingPreKey_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey build() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey buildPartial() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey result = new org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.preKeyId_ = preKeyId_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.signedPreKeyId_ = signedPreKeyId_;
+ if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+ to_bitField0_ |= 0x00000004;
+ }
+ result.baseKey_ = baseKey_;
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey) {
+ return mergeFrom((org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey other) {
+ if (other == org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.getDefaultInstance()) return this;
+ if (other.hasPreKeyId()) {
+ setPreKeyId(other.getPreKeyId());
+ }
+ if (other.hasSignedPreKeyId()) {
+ setSignedPreKeyId(other.getSignedPreKeyId());
+ }
+ if (other.hasBaseKey()) {
+ setBaseKey(other.getBaseKey());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional uint32 preKeyId = 1;
+ private int preKeyId_ ;
+ /**
+ * <code>optional uint32 preKeyId = 1;</code>
+ */
+ public boolean hasPreKeyId() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 preKeyId = 1;</code>
+ */
+ public int getPreKeyId() {
+ return preKeyId_;
+ }
+ /**
+ * <code>optional uint32 preKeyId = 1;</code>
+ */
+ public Builder setPreKeyId(int value) {
+ bitField0_ |= 0x00000001;
+ preKeyId_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 preKeyId = 1;</code>
+ */
+ public Builder clearPreKeyId() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ preKeyId_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional int32 signedPreKeyId = 3;
+ private int signedPreKeyId_ ;
+ /**
+ * <code>optional int32 signedPreKeyId = 3;</code>
+ */
+ public boolean hasSignedPreKeyId() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional int32 signedPreKeyId = 3;</code>
+ */
+ public int getSignedPreKeyId() {
+ return signedPreKeyId_;
+ }
+ /**
+ * <code>optional int32 signedPreKeyId = 3;</code>
+ */
+ public Builder setSignedPreKeyId(int value) {
+ bitField0_ |= 0x00000002;
+ signedPreKeyId_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional int32 signedPreKeyId = 3;</code>
+ */
+ public Builder clearSignedPreKeyId() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ signedPreKeyId_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional bytes baseKey = 2;
+ private com.google.protobuf.ByteString baseKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ public boolean hasBaseKey() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ public com.google.protobuf.ByteString getBaseKey() {
+ return baseKey_;
+ }
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ public Builder setBaseKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000004;
+ baseKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes baseKey = 2;</code>
+ */
+ public Builder clearBaseKey() {
+ bitField0_ = (bitField0_ & ~0x00000004);
+ baseKey_ = getDefaultInstance().getBaseKey();
+ onChanged();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.SessionStructure.PendingPreKey)
+ }
+
+ static {
+ defaultInstance = new PendingPreKey(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.SessionStructure.PendingPreKey)
+ }
+
+ private int bitField0_;
+ // optional uint32 sessionVersion = 1;
+ public static final int SESSIONVERSION_FIELD_NUMBER = 1;
+ private int sessionVersion_;
+ /**
+ * <code>optional uint32 sessionVersion = 1;</code>
+ */
+ public boolean hasSessionVersion() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 sessionVersion = 1;</code>
+ */
+ public int getSessionVersion() {
+ return sessionVersion_;
+ }
+
+ // optional bytes localIdentityPublic = 2;
+ public static final int LOCALIDENTITYPUBLIC_FIELD_NUMBER = 2;
+ private com.google.protobuf.ByteString localIdentityPublic_;
+ /**
+ * <code>optional bytes localIdentityPublic = 2;</code>
+ */
+ public boolean hasLocalIdentityPublic() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes localIdentityPublic = 2;</code>
+ */
+ public com.google.protobuf.ByteString getLocalIdentityPublic() {
+ return localIdentityPublic_;
+ }
+
+ // optional bytes remoteIdentityPublic = 3;
+ public static final int REMOTEIDENTITYPUBLIC_FIELD_NUMBER = 3;
+ private com.google.protobuf.ByteString remoteIdentityPublic_;
+ /**
+ * <code>optional bytes remoteIdentityPublic = 3;</code>
+ */
+ public boolean hasRemoteIdentityPublic() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional bytes remoteIdentityPublic = 3;</code>
+ */
+ public com.google.protobuf.ByteString getRemoteIdentityPublic() {
+ return remoteIdentityPublic_;
+ }
+
+ // optional bytes rootKey = 4;
+ public static final int ROOTKEY_FIELD_NUMBER = 4;
+ private com.google.protobuf.ByteString rootKey_;
+ /**
+ * <code>optional bytes rootKey = 4;</code>
+ */
+ public boolean hasRootKey() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+ * <code>optional bytes rootKey = 4;</code>
+ */
+ public com.google.protobuf.ByteString getRootKey() {
+ return rootKey_;
+ }
+
+ // optional uint32 previousCounter = 5;
+ public static final int PREVIOUSCOUNTER_FIELD_NUMBER = 5;
+ private int previousCounter_;
+ /**
+ * <code>optional uint32 previousCounter = 5;</code>
+ */
+ public boolean hasPreviousCounter() {
+ return ((bitField0_ & 0x00000010) == 0x00000010);
+ }
+ /**
+ * <code>optional uint32 previousCounter = 5;</code>
+ */
+ public int getPreviousCounter() {
+ return previousCounter_;
+ }
+
+ // optional .textsecure.SessionStructure.Chain senderChain = 6;
+ public static final int SENDERCHAIN_FIELD_NUMBER = 6;
+ private org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain senderChain_;
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain senderChain = 6;</code>
+ */
+ public boolean hasSenderChain() {
+ return ((bitField0_ & 0x00000020) == 0x00000020);
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain senderChain = 6;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain getSenderChain() {
+ return senderChain_;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain senderChain = 6;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.ChainOrBuilder getSenderChainOrBuilder() {
+ return senderChain_;
+ }
+
+ // repeated .textsecure.SessionStructure.Chain receiverChains = 7;
+ public static final int RECEIVERCHAINS_FIELD_NUMBER = 7;
+ private java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain> receiverChains_;
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain> getReceiverChainsList() {
+ return receiverChains_;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public java.util.List<? extends org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.ChainOrBuilder>
+ getReceiverChainsOrBuilderList() {
+ return receiverChains_;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public int getReceiverChainsCount() {
+ return receiverChains_.size();
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain getReceiverChains(int index) {
+ return receiverChains_.get(index);
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.ChainOrBuilder getReceiverChainsOrBuilder(
+ int index) {
+ return receiverChains_.get(index);
+ }
+
+ // optional .textsecure.SessionStructure.PendingKeyExchange pendingKeyExchange = 8;
+ public static final int PENDINGKEYEXCHANGE_FIELD_NUMBER = 8;
+ private org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange pendingKeyExchange_;
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingKeyExchange pendingKeyExchange = 8;</code>
+ */
+ public boolean hasPendingKeyExchange() {
+ return ((bitField0_ & 0x00000040) == 0x00000040);
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingKeyExchange pendingKeyExchange = 8;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange getPendingKeyExchange() {
+ return pendingKeyExchange_;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingKeyExchange pendingKeyExchange = 8;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchangeOrBuilder getPendingKeyExchangeOrBuilder() {
+ return pendingKeyExchange_;
+ }
+
+ // optional .textsecure.SessionStructure.PendingPreKey pendingPreKey = 9;
+ public static final int PENDINGPREKEY_FIELD_NUMBER = 9;
+ private org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey pendingPreKey_;
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingPreKey pendingPreKey = 9;</code>
+ */
+ public boolean hasPendingPreKey() {
+ return ((bitField0_ & 0x00000080) == 0x00000080);
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingPreKey pendingPreKey = 9;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey getPendingPreKey() {
+ return pendingPreKey_;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingPreKey pendingPreKey = 9;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKeyOrBuilder getPendingPreKeyOrBuilder() {
+ return pendingPreKey_;
+ }
+
+ // optional uint32 remoteRegistrationId = 10;
+ public static final int REMOTEREGISTRATIONID_FIELD_NUMBER = 10;
+ private int remoteRegistrationId_;
+ /**
+ * <code>optional uint32 remoteRegistrationId = 10;</code>
+ */
+ public boolean hasRemoteRegistrationId() {
+ return ((bitField0_ & 0x00000100) == 0x00000100);
+ }
+ /**
+ * <code>optional uint32 remoteRegistrationId = 10;</code>
+ */
+ public int getRemoteRegistrationId() {
+ return remoteRegistrationId_;
+ }
+
+ // optional uint32 localRegistrationId = 11;
+ public static final int LOCALREGISTRATIONID_FIELD_NUMBER = 11;
+ private int localRegistrationId_;
+ /**
+ * <code>optional uint32 localRegistrationId = 11;</code>
+ */
+ public boolean hasLocalRegistrationId() {
+ return ((bitField0_ & 0x00000200) == 0x00000200);
+ }
+ /**
+ * <code>optional uint32 localRegistrationId = 11;</code>
+ */
+ public int getLocalRegistrationId() {
+ return localRegistrationId_;
+ }
+
+ // optional bool needsRefresh = 12;
+ public static final int NEEDSREFRESH_FIELD_NUMBER = 12;
+ private boolean needsRefresh_;
+ /**
+ * <code>optional bool needsRefresh = 12;</code>
+ */
+ public boolean hasNeedsRefresh() {
+ return ((bitField0_ & 0x00000400) == 0x00000400);
+ }
+ /**
+ * <code>optional bool needsRefresh = 12;</code>
+ */
+ public boolean getNeedsRefresh() {
+ return needsRefresh_;
+ }
+
+ // optional bytes aliceBaseKey = 13;
+ public static final int ALICEBASEKEY_FIELD_NUMBER = 13;
+ private com.google.protobuf.ByteString aliceBaseKey_;
+ /**
+ * <code>optional bytes aliceBaseKey = 13;</code>
+ */
+ public boolean hasAliceBaseKey() {
+ return ((bitField0_ & 0x00000800) == 0x00000800);
+ }
+ /**
+ * <code>optional bytes aliceBaseKey = 13;</code>
+ */
+ public com.google.protobuf.ByteString getAliceBaseKey() {
+ return aliceBaseKey_;
+ }
+
+ private void initFields() {
+ sessionVersion_ = 0;
+ localIdentityPublic_ = com.google.protobuf.ByteString.EMPTY;
+ remoteIdentityPublic_ = com.google.protobuf.ByteString.EMPTY;
+ rootKey_ = com.google.protobuf.ByteString.EMPTY;
+ previousCounter_ = 0;
+ senderChain_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.getDefaultInstance();
+ receiverChains_ = java.util.Collections.emptyList();
+ pendingKeyExchange_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.getDefaultInstance();
+ pendingPreKey_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.getDefaultInstance();
+ remoteRegistrationId_ = 0;
+ localRegistrationId_ = 0;
+ needsRefresh_ = false;
+ aliceBaseKey_ = com.google.protobuf.ByteString.EMPTY;
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeUInt32(1, sessionVersion_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeBytes(2, localIdentityPublic_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ output.writeBytes(3, remoteIdentityPublic_);
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ output.writeBytes(4, rootKey_);
+ }
+ if (((bitField0_ & 0x00000010) == 0x00000010)) {
+ output.writeUInt32(5, previousCounter_);
+ }
+ if (((bitField0_ & 0x00000020) == 0x00000020)) {
+ output.writeMessage(6, senderChain_);
+ }
+ for (int i = 0; i < receiverChains_.size(); i++) {
+ output.writeMessage(7, receiverChains_.get(i));
+ }
+ if (((bitField0_ & 0x00000040) == 0x00000040)) {
+ output.writeMessage(8, pendingKeyExchange_);
+ }
+ if (((bitField0_ & 0x00000080) == 0x00000080)) {
+ output.writeMessage(9, pendingPreKey_);
+ }
+ if (((bitField0_ & 0x00000100) == 0x00000100)) {
+ output.writeUInt32(10, remoteRegistrationId_);
+ }
+ if (((bitField0_ & 0x00000200) == 0x00000200)) {
+ output.writeUInt32(11, localRegistrationId_);
+ }
+ if (((bitField0_ & 0x00000400) == 0x00000400)) {
+ output.writeBool(12, needsRefresh_);
+ }
+ if (((bitField0_ & 0x00000800) == 0x00000800)) {
+ output.writeBytes(13, aliceBaseKey_);
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(1, sessionVersion_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(2, localIdentityPublic_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(3, remoteIdentityPublic_);
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(4, rootKey_);
+ }
+ if (((bitField0_ & 0x00000010) == 0x00000010)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(5, previousCounter_);
+ }
+ if (((bitField0_ & 0x00000020) == 0x00000020)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeMessageSize(6, senderChain_);
+ }
+ for (int i = 0; i < receiverChains_.size(); i++) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeMessageSize(7, receiverChains_.get(i));
+ }
+ if (((bitField0_ & 0x00000040) == 0x00000040)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeMessageSize(8, pendingKeyExchange_);
+ }
+ if (((bitField0_ & 0x00000080) == 0x00000080)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeMessageSize(9, pendingPreKey_);
+ }
+ if (((bitField0_ & 0x00000100) == 0x00000100)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(10, remoteRegistrationId_);
+ }
+ if (((bitField0_ & 0x00000200) == 0x00000200)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(11, localRegistrationId_);
+ }
+ if (((bitField0_ & 0x00000400) == 0x00000400)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBoolSize(12, needsRefresh_);
+ }
+ if (((bitField0_ & 0x00000800) == 0x00000800)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(13, aliceBaseKey_);
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.SessionStructure}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.state.StorageProtos.SessionStructureOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.class, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ getSenderChainFieldBuilder();
+ getReceiverChainsFieldBuilder();
+ getPendingKeyExchangeFieldBuilder();
+ getPendingPreKeyFieldBuilder();
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ sessionVersion_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ localIdentityPublic_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ remoteIdentityPublic_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000004);
+ rootKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000008);
+ previousCounter_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000010);
+ if (senderChainBuilder_ == null) {
+ senderChain_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.getDefaultInstance();
+ } else {
+ senderChainBuilder_.clear();
+ }
+ bitField0_ = (bitField0_ & ~0x00000020);
+ if (receiverChainsBuilder_ == null) {
+ receiverChains_ = java.util.Collections.emptyList();
+ bitField0_ = (bitField0_ & ~0x00000040);
+ } else {
+ receiverChainsBuilder_.clear();
+ }
+ if (pendingKeyExchangeBuilder_ == null) {
+ pendingKeyExchange_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.getDefaultInstance();
+ } else {
+ pendingKeyExchangeBuilder_.clear();
+ }
+ bitField0_ = (bitField0_ & ~0x00000080);
+ if (pendingPreKeyBuilder_ == null) {
+ pendingPreKey_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.getDefaultInstance();
+ } else {
+ pendingPreKeyBuilder_.clear();
+ }
+ bitField0_ = (bitField0_ & ~0x00000100);
+ remoteRegistrationId_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000200);
+ localRegistrationId_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000400);
+ needsRefresh_ = false;
+ bitField0_ = (bitField0_ & ~0x00000800);
+ aliceBaseKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00001000);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SessionStructure_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure build() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure buildPartial() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure result = new org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.sessionVersion_ = sessionVersion_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.localIdentityPublic_ = localIdentityPublic_;
+ if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+ to_bitField0_ |= 0x00000004;
+ }
+ result.remoteIdentityPublic_ = remoteIdentityPublic_;
+ if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+ to_bitField0_ |= 0x00000008;
+ }
+ result.rootKey_ = rootKey_;
+ if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+ to_bitField0_ |= 0x00000010;
+ }
+ result.previousCounter_ = previousCounter_;
+ if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
+ to_bitField0_ |= 0x00000020;
+ }
+ if (senderChainBuilder_ == null) {
+ result.senderChain_ = senderChain_;
+ } else {
+ result.senderChain_ = senderChainBuilder_.build();
+ }
+ if (receiverChainsBuilder_ == null) {
+ if (((bitField0_ & 0x00000040) == 0x00000040)) {
+ receiverChains_ = java.util.Collections.unmodifiableList(receiverChains_);
+ bitField0_ = (bitField0_ & ~0x00000040);
+ }
+ result.receiverChains_ = receiverChains_;
+ } else {
+ result.receiverChains_ = receiverChainsBuilder_.build();
+ }
+ if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
+ to_bitField0_ |= 0x00000040;
+ }
+ if (pendingKeyExchangeBuilder_ == null) {
+ result.pendingKeyExchange_ = pendingKeyExchange_;
+ } else {
+ result.pendingKeyExchange_ = pendingKeyExchangeBuilder_.build();
+ }
+ if (((from_bitField0_ & 0x00000100) == 0x00000100)) {
+ to_bitField0_ |= 0x00000080;
+ }
+ if (pendingPreKeyBuilder_ == null) {
+ result.pendingPreKey_ = pendingPreKey_;
+ } else {
+ result.pendingPreKey_ = pendingPreKeyBuilder_.build();
+ }
+ if (((from_bitField0_ & 0x00000200) == 0x00000200)) {
+ to_bitField0_ |= 0x00000100;
+ }
+ result.remoteRegistrationId_ = remoteRegistrationId_;
+ if (((from_bitField0_ & 0x00000400) == 0x00000400)) {
+ to_bitField0_ |= 0x00000200;
+ }
+ result.localRegistrationId_ = localRegistrationId_;
+ if (((from_bitField0_ & 0x00000800) == 0x00000800)) {
+ to_bitField0_ |= 0x00000400;
+ }
+ result.needsRefresh_ = needsRefresh_;
+ if (((from_bitField0_ & 0x00001000) == 0x00001000)) {
+ to_bitField0_ |= 0x00000800;
+ }
+ result.aliceBaseKey_ = aliceBaseKey_;
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure) {
+ return mergeFrom((org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure other) {
+ if (other == org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.getDefaultInstance()) return this;
+ if (other.hasSessionVersion()) {
+ setSessionVersion(other.getSessionVersion());
+ }
+ if (other.hasLocalIdentityPublic()) {
+ setLocalIdentityPublic(other.getLocalIdentityPublic());
+ }
+ if (other.hasRemoteIdentityPublic()) {
+ setRemoteIdentityPublic(other.getRemoteIdentityPublic());
+ }
+ if (other.hasRootKey()) {
+ setRootKey(other.getRootKey());
+ }
+ if (other.hasPreviousCounter()) {
+ setPreviousCounter(other.getPreviousCounter());
+ }
+ if (other.hasSenderChain()) {
+ mergeSenderChain(other.getSenderChain());
+ }
+ if (receiverChainsBuilder_ == null) {
+ if (!other.receiverChains_.isEmpty()) {
+ if (receiverChains_.isEmpty()) {
+ receiverChains_ = other.receiverChains_;
+ bitField0_ = (bitField0_ & ~0x00000040);
+ } else {
+ ensureReceiverChainsIsMutable();
+ receiverChains_.addAll(other.receiverChains_);
+ }
+ onChanged();
+ }
+ } else {
+ if (!other.receiverChains_.isEmpty()) {
+ if (receiverChainsBuilder_.isEmpty()) {
+ receiverChainsBuilder_.dispose();
+ receiverChainsBuilder_ = null;
+ receiverChains_ = other.receiverChains_;
+ bitField0_ = (bitField0_ & ~0x00000040);
+ receiverChainsBuilder_ =
+ com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
+ getReceiverChainsFieldBuilder() : null;
+ } else {
+ receiverChainsBuilder_.addAllMessages(other.receiverChains_);
+ }
+ }
+ }
+ if (other.hasPendingKeyExchange()) {
+ mergePendingKeyExchange(other.getPendingKeyExchange());
+ }
+ if (other.hasPendingPreKey()) {
+ mergePendingPreKey(other.getPendingPreKey());
+ }
+ if (other.hasRemoteRegistrationId()) {
+ setRemoteRegistrationId(other.getRemoteRegistrationId());
+ }
+ if (other.hasLocalRegistrationId()) {
+ setLocalRegistrationId(other.getLocalRegistrationId());
+ }
+ if (other.hasNeedsRefresh()) {
+ setNeedsRefresh(other.getNeedsRefresh());
+ }
+ if (other.hasAliceBaseKey()) {
+ setAliceBaseKey(other.getAliceBaseKey());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional uint32 sessionVersion = 1;
+ private int sessionVersion_ ;
+ /**
+ * <code>optional uint32 sessionVersion = 1;</code>
+ */
+ public boolean hasSessionVersion() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 sessionVersion = 1;</code>
+ */
+ public int getSessionVersion() {
+ return sessionVersion_;
+ }
+ /**
+ * <code>optional uint32 sessionVersion = 1;</code>
+ */
+ public Builder setSessionVersion(int value) {
+ bitField0_ |= 0x00000001;
+ sessionVersion_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 sessionVersion = 1;</code>
+ */
+ public Builder clearSessionVersion() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ sessionVersion_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional bytes localIdentityPublic = 2;
+ private com.google.protobuf.ByteString localIdentityPublic_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes localIdentityPublic = 2;</code>
+ */
+ public boolean hasLocalIdentityPublic() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes localIdentityPublic = 2;</code>
+ */
+ public com.google.protobuf.ByteString getLocalIdentityPublic() {
+ return localIdentityPublic_;
+ }
+ /**
+ * <code>optional bytes localIdentityPublic = 2;</code>
+ */
+ public Builder setLocalIdentityPublic(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000002;
+ localIdentityPublic_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes localIdentityPublic = 2;</code>
+ */
+ public Builder clearLocalIdentityPublic() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ localIdentityPublic_ = getDefaultInstance().getLocalIdentityPublic();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes remoteIdentityPublic = 3;
+ private com.google.protobuf.ByteString remoteIdentityPublic_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes remoteIdentityPublic = 3;</code>
+ */
+ public boolean hasRemoteIdentityPublic() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional bytes remoteIdentityPublic = 3;</code>
+ */
+ public com.google.protobuf.ByteString getRemoteIdentityPublic() {
+ return remoteIdentityPublic_;
+ }
+ /**
+ * <code>optional bytes remoteIdentityPublic = 3;</code>
+ */
+ public Builder setRemoteIdentityPublic(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000004;
+ remoteIdentityPublic_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes remoteIdentityPublic = 3;</code>
+ */
+ public Builder clearRemoteIdentityPublic() {
+ bitField0_ = (bitField0_ & ~0x00000004);
+ remoteIdentityPublic_ = getDefaultInstance().getRemoteIdentityPublic();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes rootKey = 4;
+ private com.google.protobuf.ByteString rootKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes rootKey = 4;</code>
+ */
+ public boolean hasRootKey() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+ * <code>optional bytes rootKey = 4;</code>
+ */
+ public com.google.protobuf.ByteString getRootKey() {
+ return rootKey_;
+ }
+ /**
+ * <code>optional bytes rootKey = 4;</code>
+ */
+ public Builder setRootKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000008;
+ rootKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes rootKey = 4;</code>
+ */
+ public Builder clearRootKey() {
+ bitField0_ = (bitField0_ & ~0x00000008);
+ rootKey_ = getDefaultInstance().getRootKey();
+ onChanged();
+ return this;
+ }
+
+ // optional uint32 previousCounter = 5;
+ private int previousCounter_ ;
+ /**
+ * <code>optional uint32 previousCounter = 5;</code>
+ */
+ public boolean hasPreviousCounter() {
+ return ((bitField0_ & 0x00000010) == 0x00000010);
+ }
+ /**
+ * <code>optional uint32 previousCounter = 5;</code>
+ */
+ public int getPreviousCounter() {
+ return previousCounter_;
+ }
+ /**
+ * <code>optional uint32 previousCounter = 5;</code>
+ */
+ public Builder setPreviousCounter(int value) {
+ bitField0_ |= 0x00000010;
+ previousCounter_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 previousCounter = 5;</code>
+ */
+ public Builder clearPreviousCounter() {
+ bitField0_ = (bitField0_ & ~0x00000010);
+ previousCounter_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional .textsecure.SessionStructure.Chain senderChain = 6;
+ private org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain senderChain_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.getDefaultInstance();
+ private com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.ChainOrBuilder> senderChainBuilder_;
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain senderChain = 6;</code>
+ */
+ public boolean hasSenderChain() {
+ return ((bitField0_ & 0x00000020) == 0x00000020);
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain senderChain = 6;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain getSenderChain() {
+ if (senderChainBuilder_ == null) {
+ return senderChain_;
+ } else {
+ return senderChainBuilder_.getMessage();
+ }
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain senderChain = 6;</code>
+ */
+ public Builder setSenderChain(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain value) {
+ if (senderChainBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ senderChain_ = value;
+ onChanged();
+ } else {
+ senderChainBuilder_.setMessage(value);
+ }
+ bitField0_ |= 0x00000020;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain senderChain = 6;</code>
+ */
+ public Builder setSenderChain(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.Builder builderForValue) {
+ if (senderChainBuilder_ == null) {
+ senderChain_ = builderForValue.build();
+ onChanged();
+ } else {
+ senderChainBuilder_.setMessage(builderForValue.build());
+ }
+ bitField0_ |= 0x00000020;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain senderChain = 6;</code>
+ */
+ public Builder mergeSenderChain(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain value) {
+ if (senderChainBuilder_ == null) {
+ if (((bitField0_ & 0x00000020) == 0x00000020) &&
+ senderChain_ != org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.getDefaultInstance()) {
+ senderChain_ =
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.newBuilder(senderChain_).mergeFrom(value).buildPartial();
+ } else {
+ senderChain_ = value;
+ }
+ onChanged();
+ } else {
+ senderChainBuilder_.mergeFrom(value);
+ }
+ bitField0_ |= 0x00000020;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain senderChain = 6;</code>
+ */
+ public Builder clearSenderChain() {
+ if (senderChainBuilder_ == null) {
+ senderChain_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.getDefaultInstance();
+ onChanged();
+ } else {
+ senderChainBuilder_.clear();
+ }
+ bitField0_ = (bitField0_ & ~0x00000020);
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain senderChain = 6;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.Builder getSenderChainBuilder() {
+ bitField0_ |= 0x00000020;
+ onChanged();
+ return getSenderChainFieldBuilder().getBuilder();
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain senderChain = 6;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.ChainOrBuilder getSenderChainOrBuilder() {
+ if (senderChainBuilder_ != null) {
+ return senderChainBuilder_.getMessageOrBuilder();
+ } else {
+ return senderChain_;
+ }
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.Chain senderChain = 6;</code>
+ */
+ private com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.ChainOrBuilder>
+ getSenderChainFieldBuilder() {
+ if (senderChainBuilder_ == null) {
+ senderChainBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.ChainOrBuilder>(
+ senderChain_,
+ getParentForChildren(),
+ isClean());
+ senderChain_ = null;
+ }
+ return senderChainBuilder_;
+ }
+
+ // repeated .textsecure.SessionStructure.Chain receiverChains = 7;
+ private java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain> receiverChains_ =
+ java.util.Collections.emptyList();
+ private void ensureReceiverChainsIsMutable() {
+ if (!((bitField0_ & 0x00000040) == 0x00000040)) {
+ receiverChains_ = new java.util.ArrayList<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain>(receiverChains_);
+ bitField0_ |= 0x00000040;
+ }
+ }
+
+ private com.google.protobuf.RepeatedFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.ChainOrBuilder> receiverChainsBuilder_;
+
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain> getReceiverChainsList() {
+ if (receiverChainsBuilder_ == null) {
+ return java.util.Collections.unmodifiableList(receiverChains_);
+ } else {
+ return receiverChainsBuilder_.getMessageList();
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public int getReceiverChainsCount() {
+ if (receiverChainsBuilder_ == null) {
+ return receiverChains_.size();
+ } else {
+ return receiverChainsBuilder_.getCount();
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain getReceiverChains(int index) {
+ if (receiverChainsBuilder_ == null) {
+ return receiverChains_.get(index);
+ } else {
+ return receiverChainsBuilder_.getMessage(index);
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public Builder setReceiverChains(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain value) {
+ if (receiverChainsBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureReceiverChainsIsMutable();
+ receiverChains_.set(index, value);
+ onChanged();
+ } else {
+ receiverChainsBuilder_.setMessage(index, value);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public Builder setReceiverChains(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.Builder builderForValue) {
+ if (receiverChainsBuilder_ == null) {
+ ensureReceiverChainsIsMutable();
+ receiverChains_.set(index, builderForValue.build());
+ onChanged();
+ } else {
+ receiverChainsBuilder_.setMessage(index, builderForValue.build());
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public Builder addReceiverChains(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain value) {
+ if (receiverChainsBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureReceiverChainsIsMutable();
+ receiverChains_.add(value);
+ onChanged();
+ } else {
+ receiverChainsBuilder_.addMessage(value);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public Builder addReceiverChains(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain value) {
+ if (receiverChainsBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureReceiverChainsIsMutable();
+ receiverChains_.add(index, value);
+ onChanged();
+ } else {
+ receiverChainsBuilder_.addMessage(index, value);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public Builder addReceiverChains(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.Builder builderForValue) {
+ if (receiverChainsBuilder_ == null) {
+ ensureReceiverChainsIsMutable();
+ receiverChains_.add(builderForValue.build());
+ onChanged();
+ } else {
+ receiverChainsBuilder_.addMessage(builderForValue.build());
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public Builder addReceiverChains(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.Builder builderForValue) {
+ if (receiverChainsBuilder_ == null) {
+ ensureReceiverChainsIsMutable();
+ receiverChains_.add(index, builderForValue.build());
+ onChanged();
+ } else {
+ receiverChainsBuilder_.addMessage(index, builderForValue.build());
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public Builder addAllReceiverChains(
+ java.lang.Iterable<? extends org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain> values) {
+ if (receiverChainsBuilder_ == null) {
+ ensureReceiverChainsIsMutable();
+ super.addAll(values, receiverChains_);
+ onChanged();
+ } else {
+ receiverChainsBuilder_.addAllMessages(values);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public Builder clearReceiverChains() {
+ if (receiverChainsBuilder_ == null) {
+ receiverChains_ = java.util.Collections.emptyList();
+ bitField0_ = (bitField0_ & ~0x00000040);
+ onChanged();
+ } else {
+ receiverChainsBuilder_.clear();
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public Builder removeReceiverChains(int index) {
+ if (receiverChainsBuilder_ == null) {
+ ensureReceiverChainsIsMutable();
+ receiverChains_.remove(index);
+ onChanged();
+ } else {
+ receiverChainsBuilder_.remove(index);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.Builder getReceiverChainsBuilder(
+ int index) {
+ return getReceiverChainsFieldBuilder().getBuilder(index);
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.ChainOrBuilder getReceiverChainsOrBuilder(
+ int index) {
+ if (receiverChainsBuilder_ == null) {
+ return receiverChains_.get(index); } else {
+ return receiverChainsBuilder_.getMessageOrBuilder(index);
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public java.util.List<? extends org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.ChainOrBuilder>
+ getReceiverChainsOrBuilderList() {
+ if (receiverChainsBuilder_ != null) {
+ return receiverChainsBuilder_.getMessageOrBuilderList();
+ } else {
+ return java.util.Collections.unmodifiableList(receiverChains_);
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.Builder addReceiverChainsBuilder() {
+ return getReceiverChainsFieldBuilder().addBuilder(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.getDefaultInstance());
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.Builder addReceiverChainsBuilder(
+ int index) {
+ return getReceiverChainsFieldBuilder().addBuilder(
+ index, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.getDefaultInstance());
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure.Chain receiverChains = 7;</code>
+ */
+ public java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.Builder>
+ getReceiverChainsBuilderList() {
+ return getReceiverChainsFieldBuilder().getBuilderList();
+ }
+ private com.google.protobuf.RepeatedFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.ChainOrBuilder>
+ getReceiverChainsFieldBuilder() {
+ if (receiverChainsBuilder_ == null) {
+ receiverChainsBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Chain.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.ChainOrBuilder>(
+ receiverChains_,
+ ((bitField0_ & 0x00000040) == 0x00000040),
+ getParentForChildren(),
+ isClean());
+ receiverChains_ = null;
+ }
+ return receiverChainsBuilder_;
+ }
+
+ // optional .textsecure.SessionStructure.PendingKeyExchange pendingKeyExchange = 8;
+ private org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange pendingKeyExchange_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.getDefaultInstance();
+ private com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchangeOrBuilder> pendingKeyExchangeBuilder_;
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingKeyExchange pendingKeyExchange = 8;</code>
+ */
+ public boolean hasPendingKeyExchange() {
+ return ((bitField0_ & 0x00000080) == 0x00000080);
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingKeyExchange pendingKeyExchange = 8;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange getPendingKeyExchange() {
+ if (pendingKeyExchangeBuilder_ == null) {
+ return pendingKeyExchange_;
+ } else {
+ return pendingKeyExchangeBuilder_.getMessage();
+ }
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingKeyExchange pendingKeyExchange = 8;</code>
+ */
+ public Builder setPendingKeyExchange(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange value) {
+ if (pendingKeyExchangeBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ pendingKeyExchange_ = value;
+ onChanged();
+ } else {
+ pendingKeyExchangeBuilder_.setMessage(value);
+ }
+ bitField0_ |= 0x00000080;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingKeyExchange pendingKeyExchange = 8;</code>
+ */
+ public Builder setPendingKeyExchange(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.Builder builderForValue) {
+ if (pendingKeyExchangeBuilder_ == null) {
+ pendingKeyExchange_ = builderForValue.build();
+ onChanged();
+ } else {
+ pendingKeyExchangeBuilder_.setMessage(builderForValue.build());
+ }
+ bitField0_ |= 0x00000080;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingKeyExchange pendingKeyExchange = 8;</code>
+ */
+ public Builder mergePendingKeyExchange(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange value) {
+ if (pendingKeyExchangeBuilder_ == null) {
+ if (((bitField0_ & 0x00000080) == 0x00000080) &&
+ pendingKeyExchange_ != org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.getDefaultInstance()) {
+ pendingKeyExchange_ =
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.newBuilder(pendingKeyExchange_).mergeFrom(value).buildPartial();
+ } else {
+ pendingKeyExchange_ = value;
+ }
+ onChanged();
+ } else {
+ pendingKeyExchangeBuilder_.mergeFrom(value);
+ }
+ bitField0_ |= 0x00000080;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingKeyExchange pendingKeyExchange = 8;</code>
+ */
+ public Builder clearPendingKeyExchange() {
+ if (pendingKeyExchangeBuilder_ == null) {
+ pendingKeyExchange_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.getDefaultInstance();
+ onChanged();
+ } else {
+ pendingKeyExchangeBuilder_.clear();
+ }
+ bitField0_ = (bitField0_ & ~0x00000080);
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingKeyExchange pendingKeyExchange = 8;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.Builder getPendingKeyExchangeBuilder() {
+ bitField0_ |= 0x00000080;
+ onChanged();
+ return getPendingKeyExchangeFieldBuilder().getBuilder();
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingKeyExchange pendingKeyExchange = 8;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchangeOrBuilder getPendingKeyExchangeOrBuilder() {
+ if (pendingKeyExchangeBuilder_ != null) {
+ return pendingKeyExchangeBuilder_.getMessageOrBuilder();
+ } else {
+ return pendingKeyExchange_;
+ }
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingKeyExchange pendingKeyExchange = 8;</code>
+ */
+ private com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchangeOrBuilder>
+ getPendingKeyExchangeFieldBuilder() {
+ if (pendingKeyExchangeBuilder_ == null) {
+ pendingKeyExchangeBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchange.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingKeyExchangeOrBuilder>(
+ pendingKeyExchange_,
+ getParentForChildren(),
+ isClean());
+ pendingKeyExchange_ = null;
+ }
+ return pendingKeyExchangeBuilder_;
+ }
+
+ // optional .textsecure.SessionStructure.PendingPreKey pendingPreKey = 9;
+ private org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey pendingPreKey_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.getDefaultInstance();
+ private com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKeyOrBuilder> pendingPreKeyBuilder_;
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingPreKey pendingPreKey = 9;</code>
+ */
+ public boolean hasPendingPreKey() {
+ return ((bitField0_ & 0x00000100) == 0x00000100);
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingPreKey pendingPreKey = 9;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey getPendingPreKey() {
+ if (pendingPreKeyBuilder_ == null) {
+ return pendingPreKey_;
+ } else {
+ return pendingPreKeyBuilder_.getMessage();
+ }
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingPreKey pendingPreKey = 9;</code>
+ */
+ public Builder setPendingPreKey(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey value) {
+ if (pendingPreKeyBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ pendingPreKey_ = value;
+ onChanged();
+ } else {
+ pendingPreKeyBuilder_.setMessage(value);
+ }
+ bitField0_ |= 0x00000100;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingPreKey pendingPreKey = 9;</code>
+ */
+ public Builder setPendingPreKey(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.Builder builderForValue) {
+ if (pendingPreKeyBuilder_ == null) {
+ pendingPreKey_ = builderForValue.build();
+ onChanged();
+ } else {
+ pendingPreKeyBuilder_.setMessage(builderForValue.build());
+ }
+ bitField0_ |= 0x00000100;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingPreKey pendingPreKey = 9;</code>
+ */
+ public Builder mergePendingPreKey(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey value) {
+ if (pendingPreKeyBuilder_ == null) {
+ if (((bitField0_ & 0x00000100) == 0x00000100) &&
+ pendingPreKey_ != org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.getDefaultInstance()) {
+ pendingPreKey_ =
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.newBuilder(pendingPreKey_).mergeFrom(value).buildPartial();
+ } else {
+ pendingPreKey_ = value;
+ }
+ onChanged();
+ } else {
+ pendingPreKeyBuilder_.mergeFrom(value);
+ }
+ bitField0_ |= 0x00000100;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingPreKey pendingPreKey = 9;</code>
+ */
+ public Builder clearPendingPreKey() {
+ if (pendingPreKeyBuilder_ == null) {
+ pendingPreKey_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.getDefaultInstance();
+ onChanged();
+ } else {
+ pendingPreKeyBuilder_.clear();
+ }
+ bitField0_ = (bitField0_ & ~0x00000100);
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingPreKey pendingPreKey = 9;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.Builder getPendingPreKeyBuilder() {
+ bitField0_ |= 0x00000100;
+ onChanged();
+ return getPendingPreKeyFieldBuilder().getBuilder();
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingPreKey pendingPreKey = 9;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKeyOrBuilder getPendingPreKeyOrBuilder() {
+ if (pendingPreKeyBuilder_ != null) {
+ return pendingPreKeyBuilder_.getMessageOrBuilder();
+ } else {
+ return pendingPreKey_;
+ }
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure.PendingPreKey pendingPreKey = 9;</code>
+ */
+ private com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKeyOrBuilder>
+ getPendingPreKeyFieldBuilder() {
+ if (pendingPreKeyBuilder_ == null) {
+ pendingPreKeyBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKey.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PendingPreKeyOrBuilder>(
+ pendingPreKey_,
+ getParentForChildren(),
+ isClean());
+ pendingPreKey_ = null;
+ }
+ return pendingPreKeyBuilder_;
+ }
+
+ // optional uint32 remoteRegistrationId = 10;
+ private int remoteRegistrationId_ ;
+ /**
+ * <code>optional uint32 remoteRegistrationId = 10;</code>
+ */
+ public boolean hasRemoteRegistrationId() {
+ return ((bitField0_ & 0x00000200) == 0x00000200);
+ }
+ /**
+ * <code>optional uint32 remoteRegistrationId = 10;</code>
+ */
+ public int getRemoteRegistrationId() {
+ return remoteRegistrationId_;
+ }
+ /**
+ * <code>optional uint32 remoteRegistrationId = 10;</code>
+ */
+ public Builder setRemoteRegistrationId(int value) {
+ bitField0_ |= 0x00000200;
+ remoteRegistrationId_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 remoteRegistrationId = 10;</code>
+ */
+ public Builder clearRemoteRegistrationId() {
+ bitField0_ = (bitField0_ & ~0x00000200);
+ remoteRegistrationId_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional uint32 localRegistrationId = 11;
+ private int localRegistrationId_ ;
+ /**
+ * <code>optional uint32 localRegistrationId = 11;</code>
+ */
+ public boolean hasLocalRegistrationId() {
+ return ((bitField0_ & 0x00000400) == 0x00000400);
+ }
+ /**
+ * <code>optional uint32 localRegistrationId = 11;</code>
+ */
+ public int getLocalRegistrationId() {
+ return localRegistrationId_;
+ }
+ /**
+ * <code>optional uint32 localRegistrationId = 11;</code>
+ */
+ public Builder setLocalRegistrationId(int value) {
+ bitField0_ |= 0x00000400;
+ localRegistrationId_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 localRegistrationId = 11;</code>
+ */
+ public Builder clearLocalRegistrationId() {
+ bitField0_ = (bitField0_ & ~0x00000400);
+ localRegistrationId_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional bool needsRefresh = 12;
+ private boolean needsRefresh_ ;
+ /**
+ * <code>optional bool needsRefresh = 12;</code>
+ */
+ public boolean hasNeedsRefresh() {
+ return ((bitField0_ & 0x00000800) == 0x00000800);
+ }
+ /**
+ * <code>optional bool needsRefresh = 12;</code>
+ */
+ public boolean getNeedsRefresh() {
+ return needsRefresh_;
+ }
+ /**
+ * <code>optional bool needsRefresh = 12;</code>
+ */
+ public Builder setNeedsRefresh(boolean value) {
+ bitField0_ |= 0x00000800;
+ needsRefresh_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bool needsRefresh = 12;</code>
+ */
+ public Builder clearNeedsRefresh() {
+ bitField0_ = (bitField0_ & ~0x00000800);
+ needsRefresh_ = false;
+ onChanged();
+ return this;
+ }
+
+ // optional bytes aliceBaseKey = 13;
+ private com.google.protobuf.ByteString aliceBaseKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes aliceBaseKey = 13;</code>
+ */
+ public boolean hasAliceBaseKey() {
+ return ((bitField0_ & 0x00001000) == 0x00001000);
+ }
+ /**
+ * <code>optional bytes aliceBaseKey = 13;</code>
+ */
+ public com.google.protobuf.ByteString getAliceBaseKey() {
+ return aliceBaseKey_;
+ }
+ /**
+ * <code>optional bytes aliceBaseKey = 13;</code>
+ */
+ public Builder setAliceBaseKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00001000;
+ aliceBaseKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes aliceBaseKey = 13;</code>
+ */
+ public Builder clearAliceBaseKey() {
+ bitField0_ = (bitField0_ & ~0x00001000);
+ aliceBaseKey_ = getDefaultInstance().getAliceBaseKey();
+ onChanged();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.SessionStructure)
+ }
+
+ static {
+ defaultInstance = new SessionStructure(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.SessionStructure)
+ }
+
+ public interface RecordStructureOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional .textsecure.SessionStructure currentSession = 1;
+ /**
+ * <code>optional .textsecure.SessionStructure currentSession = 1;</code>
+ */
+ boolean hasCurrentSession();
+ /**
+ * <code>optional .textsecure.SessionStructure currentSession = 1;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure getCurrentSession();
+ /**
+ * <code>optional .textsecure.SessionStructure currentSession = 1;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructureOrBuilder getCurrentSessionOrBuilder();
+
+ // repeated .textsecure.SessionStructure previousSessions = 2;
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure>
+ getPreviousSessionsList();
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure getPreviousSessions(int index);
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ int getPreviousSessionsCount();
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ java.util.List<? extends org.whispersystems.libaxolotl.state.StorageProtos.SessionStructureOrBuilder>
+ getPreviousSessionsOrBuilderList();
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructureOrBuilder getPreviousSessionsOrBuilder(
+ int index);
+ }
+ /**
+ * Protobuf type {@code textsecure.RecordStructure}
+ */
+ public static final class RecordStructure extends
+ com.google.protobuf.GeneratedMessage
+ implements RecordStructureOrBuilder {
+ // Use RecordStructure.newBuilder() to construct.
+ private RecordStructure(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private RecordStructure(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final RecordStructure defaultInstance;
+ public static RecordStructure getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public RecordStructure getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private RecordStructure(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 10: {
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Builder subBuilder = null;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ subBuilder = currentSession_.toBuilder();
+ }
+ currentSession_ = input.readMessage(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PARSER, extensionRegistry);
+ if (subBuilder != null) {
+ subBuilder.mergeFrom(currentSession_);
+ currentSession_ = subBuilder.buildPartial();
+ }
+ bitField0_ |= 0x00000001;
+ break;
+ }
+ case 18: {
+ if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
+ previousSessions_ = new java.util.ArrayList<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure>();
+ mutable_bitField0_ |= 0x00000002;
+ }
+ previousSessions_.add(input.readMessage(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.PARSER, extensionRegistry));
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
+ previousSessions_ = java.util.Collections.unmodifiableList(previousSessions_);
+ }
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_RecordStructure_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_RecordStructure_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure.class, org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<RecordStructure> PARSER =
+ new com.google.protobuf.AbstractParser<RecordStructure>() {
+ public RecordStructure parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new RecordStructure(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<RecordStructure> getParserForType() {
+ return PARSER;
+ }
+
+ private int bitField0_;
+ // optional .textsecure.SessionStructure currentSession = 1;
+ public static final int CURRENTSESSION_FIELD_NUMBER = 1;
+ private org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure currentSession_;
+ /**
+ * <code>optional .textsecure.SessionStructure currentSession = 1;</code>
+ */
+ public boolean hasCurrentSession() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure currentSession = 1;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure getCurrentSession() {
+ return currentSession_;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure currentSession = 1;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructureOrBuilder getCurrentSessionOrBuilder() {
+ return currentSession_;
+ }
+
+ // repeated .textsecure.SessionStructure previousSessions = 2;
+ public static final int PREVIOUSSESSIONS_FIELD_NUMBER = 2;
+ private java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure> previousSessions_;
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure> getPreviousSessionsList() {
+ return previousSessions_;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public java.util.List<? extends org.whispersystems.libaxolotl.state.StorageProtos.SessionStructureOrBuilder>
+ getPreviousSessionsOrBuilderList() {
+ return previousSessions_;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public int getPreviousSessionsCount() {
+ return previousSessions_.size();
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure getPreviousSessions(int index) {
+ return previousSessions_.get(index);
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructureOrBuilder getPreviousSessionsOrBuilder(
+ int index) {
+ return previousSessions_.get(index);
+ }
+
+ private void initFields() {
+ currentSession_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.getDefaultInstance();
+ previousSessions_ = java.util.Collections.emptyList();
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeMessage(1, currentSession_);
+ }
+ for (int i = 0; i < previousSessions_.size(); i++) {
+ output.writeMessage(2, previousSessions_.get(i));
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeMessageSize(1, currentSession_);
+ }
+ for (int i = 0; i < previousSessions_.size(); i++) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeMessageSize(2, previousSessions_.get(i));
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.RecordStructure}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.state.StorageProtos.RecordStructureOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_RecordStructure_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_RecordStructure_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure.class, org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ getCurrentSessionFieldBuilder();
+ getPreviousSessionsFieldBuilder();
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ if (currentSessionBuilder_ == null) {
+ currentSession_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.getDefaultInstance();
+ } else {
+ currentSessionBuilder_.clear();
+ }
+ bitField0_ = (bitField0_ & ~0x00000001);
+ if (previousSessionsBuilder_ == null) {
+ previousSessions_ = java.util.Collections.emptyList();
+ bitField0_ = (bitField0_ & ~0x00000002);
+ } else {
+ previousSessionsBuilder_.clear();
+ }
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_RecordStructure_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure build() {
+ org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure buildPartial() {
+ org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure result = new org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ if (currentSessionBuilder_ == null) {
+ result.currentSession_ = currentSession_;
+ } else {
+ result.currentSession_ = currentSessionBuilder_.build();
+ }
+ if (previousSessionsBuilder_ == null) {
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ previousSessions_ = java.util.Collections.unmodifiableList(previousSessions_);
+ bitField0_ = (bitField0_ & ~0x00000002);
+ }
+ result.previousSessions_ = previousSessions_;
+ } else {
+ result.previousSessions_ = previousSessionsBuilder_.build();
+ }
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure) {
+ return mergeFrom((org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure other) {
+ if (other == org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure.getDefaultInstance()) return this;
+ if (other.hasCurrentSession()) {
+ mergeCurrentSession(other.getCurrentSession());
+ }
+ if (previousSessionsBuilder_ == null) {
+ if (!other.previousSessions_.isEmpty()) {
+ if (previousSessions_.isEmpty()) {
+ previousSessions_ = other.previousSessions_;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ } else {
+ ensurePreviousSessionsIsMutable();
+ previousSessions_.addAll(other.previousSessions_);
+ }
+ onChanged();
+ }
+ } else {
+ if (!other.previousSessions_.isEmpty()) {
+ if (previousSessionsBuilder_.isEmpty()) {
+ previousSessionsBuilder_.dispose();
+ previousSessionsBuilder_ = null;
+ previousSessions_ = other.previousSessions_;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ previousSessionsBuilder_ =
+ com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
+ getPreviousSessionsFieldBuilder() : null;
+ } else {
+ previousSessionsBuilder_.addAllMessages(other.previousSessions_);
+ }
+ }
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.state.StorageProtos.RecordStructure) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional .textsecure.SessionStructure currentSession = 1;
+ private org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure currentSession_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.getDefaultInstance();
+ private com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructureOrBuilder> currentSessionBuilder_;
+ /**
+ * <code>optional .textsecure.SessionStructure currentSession = 1;</code>
+ */
+ public boolean hasCurrentSession() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure currentSession = 1;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure getCurrentSession() {
+ if (currentSessionBuilder_ == null) {
+ return currentSession_;
+ } else {
+ return currentSessionBuilder_.getMessage();
+ }
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure currentSession = 1;</code>
+ */
+ public Builder setCurrentSession(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure value) {
+ if (currentSessionBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ currentSession_ = value;
+ onChanged();
+ } else {
+ currentSessionBuilder_.setMessage(value);
+ }
+ bitField0_ |= 0x00000001;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure currentSession = 1;</code>
+ */
+ public Builder setCurrentSession(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Builder builderForValue) {
+ if (currentSessionBuilder_ == null) {
+ currentSession_ = builderForValue.build();
+ onChanged();
+ } else {
+ currentSessionBuilder_.setMessage(builderForValue.build());
+ }
+ bitField0_ |= 0x00000001;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure currentSession = 1;</code>
+ */
+ public Builder mergeCurrentSession(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure value) {
+ if (currentSessionBuilder_ == null) {
+ if (((bitField0_ & 0x00000001) == 0x00000001) &&
+ currentSession_ != org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.getDefaultInstance()) {
+ currentSession_ =
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.newBuilder(currentSession_).mergeFrom(value).buildPartial();
+ } else {
+ currentSession_ = value;
+ }
+ onChanged();
+ } else {
+ currentSessionBuilder_.mergeFrom(value);
+ }
+ bitField0_ |= 0x00000001;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure currentSession = 1;</code>
+ */
+ public Builder clearCurrentSession() {
+ if (currentSessionBuilder_ == null) {
+ currentSession_ = org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.getDefaultInstance();
+ onChanged();
+ } else {
+ currentSessionBuilder_.clear();
+ }
+ bitField0_ = (bitField0_ & ~0x00000001);
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure currentSession = 1;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Builder getCurrentSessionBuilder() {
+ bitField0_ |= 0x00000001;
+ onChanged();
+ return getCurrentSessionFieldBuilder().getBuilder();
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure currentSession = 1;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructureOrBuilder getCurrentSessionOrBuilder() {
+ if (currentSessionBuilder_ != null) {
+ return currentSessionBuilder_.getMessageOrBuilder();
+ } else {
+ return currentSession_;
+ }
+ }
+ /**
+ * <code>optional .textsecure.SessionStructure currentSession = 1;</code>
+ */
+ private com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructureOrBuilder>
+ getCurrentSessionFieldBuilder() {
+ if (currentSessionBuilder_ == null) {
+ currentSessionBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructureOrBuilder>(
+ currentSession_,
+ getParentForChildren(),
+ isClean());
+ currentSession_ = null;
+ }
+ return currentSessionBuilder_;
+ }
+
+ // repeated .textsecure.SessionStructure previousSessions = 2;
+ private java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure> previousSessions_ =
+ java.util.Collections.emptyList();
+ private void ensurePreviousSessionsIsMutable() {
+ if (!((bitField0_ & 0x00000002) == 0x00000002)) {
+ previousSessions_ = new java.util.ArrayList<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure>(previousSessions_);
+ bitField0_ |= 0x00000002;
+ }
+ }
+
+ private com.google.protobuf.RepeatedFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructureOrBuilder> previousSessionsBuilder_;
+
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure> getPreviousSessionsList() {
+ if (previousSessionsBuilder_ == null) {
+ return java.util.Collections.unmodifiableList(previousSessions_);
+ } else {
+ return previousSessionsBuilder_.getMessageList();
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public int getPreviousSessionsCount() {
+ if (previousSessionsBuilder_ == null) {
+ return previousSessions_.size();
+ } else {
+ return previousSessionsBuilder_.getCount();
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure getPreviousSessions(int index) {
+ if (previousSessionsBuilder_ == null) {
+ return previousSessions_.get(index);
+ } else {
+ return previousSessionsBuilder_.getMessage(index);
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public Builder setPreviousSessions(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure value) {
+ if (previousSessionsBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensurePreviousSessionsIsMutable();
+ previousSessions_.set(index, value);
+ onChanged();
+ } else {
+ previousSessionsBuilder_.setMessage(index, value);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public Builder setPreviousSessions(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Builder builderForValue) {
+ if (previousSessionsBuilder_ == null) {
+ ensurePreviousSessionsIsMutable();
+ previousSessions_.set(index, builderForValue.build());
+ onChanged();
+ } else {
+ previousSessionsBuilder_.setMessage(index, builderForValue.build());
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public Builder addPreviousSessions(org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure value) {
+ if (previousSessionsBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensurePreviousSessionsIsMutable();
+ previousSessions_.add(value);
+ onChanged();
+ } else {
+ previousSessionsBuilder_.addMessage(value);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public Builder addPreviousSessions(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure value) {
+ if (previousSessionsBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensurePreviousSessionsIsMutable();
+ previousSessions_.add(index, value);
+ onChanged();
+ } else {
+ previousSessionsBuilder_.addMessage(index, value);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public Builder addPreviousSessions(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Builder builderForValue) {
+ if (previousSessionsBuilder_ == null) {
+ ensurePreviousSessionsIsMutable();
+ previousSessions_.add(builderForValue.build());
+ onChanged();
+ } else {
+ previousSessionsBuilder_.addMessage(builderForValue.build());
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public Builder addPreviousSessions(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Builder builderForValue) {
+ if (previousSessionsBuilder_ == null) {
+ ensurePreviousSessionsIsMutable();
+ previousSessions_.add(index, builderForValue.build());
+ onChanged();
+ } else {
+ previousSessionsBuilder_.addMessage(index, builderForValue.build());
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public Builder addAllPreviousSessions(
+ java.lang.Iterable<? extends org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure> values) {
+ if (previousSessionsBuilder_ == null) {
+ ensurePreviousSessionsIsMutable();
+ super.addAll(values, previousSessions_);
+ onChanged();
+ } else {
+ previousSessionsBuilder_.addAllMessages(values);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public Builder clearPreviousSessions() {
+ if (previousSessionsBuilder_ == null) {
+ previousSessions_ = java.util.Collections.emptyList();
+ bitField0_ = (bitField0_ & ~0x00000002);
+ onChanged();
+ } else {
+ previousSessionsBuilder_.clear();
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public Builder removePreviousSessions(int index) {
+ if (previousSessionsBuilder_ == null) {
+ ensurePreviousSessionsIsMutable();
+ previousSessions_.remove(index);
+ onChanged();
+ } else {
+ previousSessionsBuilder_.remove(index);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Builder getPreviousSessionsBuilder(
+ int index) {
+ return getPreviousSessionsFieldBuilder().getBuilder(index);
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructureOrBuilder getPreviousSessionsOrBuilder(
+ int index) {
+ if (previousSessionsBuilder_ == null) {
+ return previousSessions_.get(index); } else {
+ return previousSessionsBuilder_.getMessageOrBuilder(index);
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public java.util.List<? extends org.whispersystems.libaxolotl.state.StorageProtos.SessionStructureOrBuilder>
+ getPreviousSessionsOrBuilderList() {
+ if (previousSessionsBuilder_ != null) {
+ return previousSessionsBuilder_.getMessageOrBuilderList();
+ } else {
+ return java.util.Collections.unmodifiableList(previousSessions_);
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Builder addPreviousSessionsBuilder() {
+ return getPreviousSessionsFieldBuilder().addBuilder(
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.getDefaultInstance());
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Builder addPreviousSessionsBuilder(
+ int index) {
+ return getPreviousSessionsFieldBuilder().addBuilder(
+ index, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.getDefaultInstance());
+ }
+ /**
+ * <code>repeated .textsecure.SessionStructure previousSessions = 2;</code>
+ */
+ public java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Builder>
+ getPreviousSessionsBuilderList() {
+ return getPreviousSessionsFieldBuilder().getBuilderList();
+ }
+ private com.google.protobuf.RepeatedFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructureOrBuilder>
+ getPreviousSessionsFieldBuilder() {
+ if (previousSessionsBuilder_ == null) {
+ previousSessionsBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructure.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SessionStructureOrBuilder>(
+ previousSessions_,
+ ((bitField0_ & 0x00000002) == 0x00000002),
+ getParentForChildren(),
+ isClean());
+ previousSessions_ = null;
+ }
+ return previousSessionsBuilder_;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.RecordStructure)
+ }
+
+ static {
+ defaultInstance = new RecordStructure(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.RecordStructure)
+ }
+
+ public interface PreKeyRecordStructureOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional uint32 id = 1;
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ boolean hasId();
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ int getId();
+
+ // optional bytes publicKey = 2;
+ /**
+ * <code>optional bytes publicKey = 2;</code>
+ */
+ boolean hasPublicKey();
+ /**
+ * <code>optional bytes publicKey = 2;</code>
+ */
+ com.google.protobuf.ByteString getPublicKey();
+
+ // optional bytes privateKey = 3;
+ /**
+ * <code>optional bytes privateKey = 3;</code>
+ */
+ boolean hasPrivateKey();
+ /**
+ * <code>optional bytes privateKey = 3;</code>
+ */
+ com.google.protobuf.ByteString getPrivateKey();
+ }
+ /**
+ * Protobuf type {@code textsecure.PreKeyRecordStructure}
+ */
+ public static final class PreKeyRecordStructure extends
+ com.google.protobuf.GeneratedMessage
+ implements PreKeyRecordStructureOrBuilder {
+ // Use PreKeyRecordStructure.newBuilder() to construct.
+ private PreKeyRecordStructure(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private PreKeyRecordStructure(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final PreKeyRecordStructure defaultInstance;
+ public static PreKeyRecordStructure getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public PreKeyRecordStructure getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private PreKeyRecordStructure(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 8: {
+ bitField0_ |= 0x00000001;
+ id_ = input.readUInt32();
+ break;
+ }
+ case 18: {
+ bitField0_ |= 0x00000002;
+ publicKey_ = input.readBytes();
+ break;
+ }
+ case 26: {
+ bitField0_ |= 0x00000004;
+ privateKey_ = input.readBytes();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_PreKeyRecordStructure_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_PreKeyRecordStructure_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure.class, org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<PreKeyRecordStructure> PARSER =
+ new com.google.protobuf.AbstractParser<PreKeyRecordStructure>() {
+ public PreKeyRecordStructure parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new PreKeyRecordStructure(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<PreKeyRecordStructure> getParserForType() {
+ return PARSER;
+ }
+
+ private int bitField0_;
+ // optional uint32 id = 1;
+ public static final int ID_FIELD_NUMBER = 1;
+ private int id_;
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public boolean hasId() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public int getId() {
+ return id_;
+ }
+
+ // optional bytes publicKey = 2;
+ public static final int PUBLICKEY_FIELD_NUMBER = 2;
+ private com.google.protobuf.ByteString publicKey_;
+ /**
+ * <code>optional bytes publicKey = 2;</code>
+ */
+ public boolean hasPublicKey() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes publicKey = 2;</code>
+ */
+ public com.google.protobuf.ByteString getPublicKey() {
+ return publicKey_;
+ }
+
+ // optional bytes privateKey = 3;
+ public static final int PRIVATEKEY_FIELD_NUMBER = 3;
+ private com.google.protobuf.ByteString privateKey_;
+ /**
+ * <code>optional bytes privateKey = 3;</code>
+ */
+ public boolean hasPrivateKey() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional bytes privateKey = 3;</code>
+ */
+ public com.google.protobuf.ByteString getPrivateKey() {
+ return privateKey_;
+ }
+
+ private void initFields() {
+ id_ = 0;
+ publicKey_ = com.google.protobuf.ByteString.EMPTY;
+ privateKey_ = com.google.protobuf.ByteString.EMPTY;
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeUInt32(1, id_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeBytes(2, publicKey_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ output.writeBytes(3, privateKey_);
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(1, id_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(2, publicKey_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(3, privateKey_);
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.PreKeyRecordStructure}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructureOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_PreKeyRecordStructure_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_PreKeyRecordStructure_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure.class, org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ id_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ publicKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ privateKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000004);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_PreKeyRecordStructure_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure build() {
+ org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure buildPartial() {
+ org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure result = new org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.id_ = id_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.publicKey_ = publicKey_;
+ if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+ to_bitField0_ |= 0x00000004;
+ }
+ result.privateKey_ = privateKey_;
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure) {
+ return mergeFrom((org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure other) {
+ if (other == org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure.getDefaultInstance()) return this;
+ if (other.hasId()) {
+ setId(other.getId());
+ }
+ if (other.hasPublicKey()) {
+ setPublicKey(other.getPublicKey());
+ }
+ if (other.hasPrivateKey()) {
+ setPrivateKey(other.getPrivateKey());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.state.StorageProtos.PreKeyRecordStructure) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional uint32 id = 1;
+ private int id_ ;
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public boolean hasId() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public int getId() {
+ return id_;
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public Builder setId(int value) {
+ bitField0_ |= 0x00000001;
+ id_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public Builder clearId() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ id_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional bytes publicKey = 2;
+ private com.google.protobuf.ByteString publicKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes publicKey = 2;</code>
+ */
+ public boolean hasPublicKey() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes publicKey = 2;</code>
+ */
+ public com.google.protobuf.ByteString getPublicKey() {
+ return publicKey_;
+ }
+ /**
+ * <code>optional bytes publicKey = 2;</code>
+ */
+ public Builder setPublicKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000002;
+ publicKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes publicKey = 2;</code>
+ */
+ public Builder clearPublicKey() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ publicKey_ = getDefaultInstance().getPublicKey();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes privateKey = 3;
+ private com.google.protobuf.ByteString privateKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes privateKey = 3;</code>
+ */
+ public boolean hasPrivateKey() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional bytes privateKey = 3;</code>
+ */
+ public com.google.protobuf.ByteString getPrivateKey() {
+ return privateKey_;
+ }
+ /**
+ * <code>optional bytes privateKey = 3;</code>
+ */
+ public Builder setPrivateKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000004;
+ privateKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes privateKey = 3;</code>
+ */
+ public Builder clearPrivateKey() {
+ bitField0_ = (bitField0_ & ~0x00000004);
+ privateKey_ = getDefaultInstance().getPrivateKey();
+ onChanged();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.PreKeyRecordStructure)
+ }
+
+ static {
+ defaultInstance = new PreKeyRecordStructure(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.PreKeyRecordStructure)
+ }
+
+ public interface SignedPreKeyRecordStructureOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional uint32 id = 1;
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ boolean hasId();
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ int getId();
+
+ // optional bytes publicKey = 2;
+ /**
+ * <code>optional bytes publicKey = 2;</code>
+ */
+ boolean hasPublicKey();
+ /**
+ * <code>optional bytes publicKey = 2;</code>
+ */
+ com.google.protobuf.ByteString getPublicKey();
+
+ // optional bytes privateKey = 3;
+ /**
+ * <code>optional bytes privateKey = 3;</code>
+ */
+ boolean hasPrivateKey();
+ /**
+ * <code>optional bytes privateKey = 3;</code>
+ */
+ com.google.protobuf.ByteString getPrivateKey();
+
+ // optional bytes signature = 4;
+ /**
+ * <code>optional bytes signature = 4;</code>
+ */
+ boolean hasSignature();
+ /**
+ * <code>optional bytes signature = 4;</code>
+ */
+ com.google.protobuf.ByteString getSignature();
+
+ // optional fixed64 timestamp = 5;
+ /**
+ * <code>optional fixed64 timestamp = 5;</code>
+ */
+ boolean hasTimestamp();
+ /**
+ * <code>optional fixed64 timestamp = 5;</code>
+ */
+ long getTimestamp();
+ }
+ /**
+ * Protobuf type {@code textsecure.SignedPreKeyRecordStructure}
+ */
+ public static final class SignedPreKeyRecordStructure extends
+ com.google.protobuf.GeneratedMessage
+ implements SignedPreKeyRecordStructureOrBuilder {
+ // Use SignedPreKeyRecordStructure.newBuilder() to construct.
+ private SignedPreKeyRecordStructure(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private SignedPreKeyRecordStructure(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final SignedPreKeyRecordStructure defaultInstance;
+ public static SignedPreKeyRecordStructure getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public SignedPreKeyRecordStructure getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private SignedPreKeyRecordStructure(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 8: {
+ bitField0_ |= 0x00000001;
+ id_ = input.readUInt32();
+ break;
+ }
+ case 18: {
+ bitField0_ |= 0x00000002;
+ publicKey_ = input.readBytes();
+ break;
+ }
+ case 26: {
+ bitField0_ |= 0x00000004;
+ privateKey_ = input.readBytes();
+ break;
+ }
+ case 34: {
+ bitField0_ |= 0x00000008;
+ signature_ = input.readBytes();
+ break;
+ }
+ case 41: {
+ bitField0_ |= 0x00000010;
+ timestamp_ = input.readFixed64();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SignedPreKeyRecordStructure_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SignedPreKeyRecordStructure_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure.class, org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<SignedPreKeyRecordStructure> PARSER =
+ new com.google.protobuf.AbstractParser<SignedPreKeyRecordStructure>() {
+ public SignedPreKeyRecordStructure parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new SignedPreKeyRecordStructure(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<SignedPreKeyRecordStructure> getParserForType() {
+ return PARSER;
+ }
+
+ private int bitField0_;
+ // optional uint32 id = 1;
+ public static final int ID_FIELD_NUMBER = 1;
+ private int id_;
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public boolean hasId() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public int getId() {
+ return id_;
+ }
+
+ // optional bytes publicKey = 2;
+ public static final int PUBLICKEY_FIELD_NUMBER = 2;
+ private com.google.protobuf.ByteString publicKey_;
+ /**
+ * <code>optional bytes publicKey = 2;</code>
+ */
+ public boolean hasPublicKey() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes publicKey = 2;</code>
+ */
+ public com.google.protobuf.ByteString getPublicKey() {
+ return publicKey_;
+ }
+
+ // optional bytes privateKey = 3;
+ public static final int PRIVATEKEY_FIELD_NUMBER = 3;
+ private com.google.protobuf.ByteString privateKey_;
+ /**
+ * <code>optional bytes privateKey = 3;</code>
+ */
+ public boolean hasPrivateKey() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional bytes privateKey = 3;</code>
+ */
+ public com.google.protobuf.ByteString getPrivateKey() {
+ return privateKey_;
+ }
+
+ // optional bytes signature = 4;
+ public static final int SIGNATURE_FIELD_NUMBER = 4;
+ private com.google.protobuf.ByteString signature_;
+ /**
+ * <code>optional bytes signature = 4;</code>
+ */
+ public boolean hasSignature() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+ * <code>optional bytes signature = 4;</code>
+ */
+ public com.google.protobuf.ByteString getSignature() {
+ return signature_;
+ }
+
+ // optional fixed64 timestamp = 5;
+ public static final int TIMESTAMP_FIELD_NUMBER = 5;
+ private long timestamp_;
+ /**
+ * <code>optional fixed64 timestamp = 5;</code>
+ */
+ public boolean hasTimestamp() {
+ return ((bitField0_ & 0x00000010) == 0x00000010);
+ }
+ /**
+ * <code>optional fixed64 timestamp = 5;</code>
+ */
+ public long getTimestamp() {
+ return timestamp_;
+ }
+
+ private void initFields() {
+ id_ = 0;
+ publicKey_ = com.google.protobuf.ByteString.EMPTY;
+ privateKey_ = com.google.protobuf.ByteString.EMPTY;
+ signature_ = com.google.protobuf.ByteString.EMPTY;
+ timestamp_ = 0L;
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeUInt32(1, id_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeBytes(2, publicKey_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ output.writeBytes(3, privateKey_);
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ output.writeBytes(4, signature_);
+ }
+ if (((bitField0_ & 0x00000010) == 0x00000010)) {
+ output.writeFixed64(5, timestamp_);
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(1, id_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(2, publicKey_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(3, privateKey_);
+ }
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(4, signature_);
+ }
+ if (((bitField0_ & 0x00000010) == 0x00000010)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeFixed64Size(5, timestamp_);
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.SignedPreKeyRecordStructure}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructureOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SignedPreKeyRecordStructure_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SignedPreKeyRecordStructure_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure.class, org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ id_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ publicKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ privateKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000004);
+ signature_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000008);
+ timestamp_ = 0L;
+ bitField0_ = (bitField0_ & ~0x00000010);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SignedPreKeyRecordStructure_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure build() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure buildPartial() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure result = new org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.id_ = id_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.publicKey_ = publicKey_;
+ if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+ to_bitField0_ |= 0x00000004;
+ }
+ result.privateKey_ = privateKey_;
+ if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
+ to_bitField0_ |= 0x00000008;
+ }
+ result.signature_ = signature_;
+ if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
+ to_bitField0_ |= 0x00000010;
+ }
+ result.timestamp_ = timestamp_;
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure) {
+ return mergeFrom((org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure other) {
+ if (other == org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure.getDefaultInstance()) return this;
+ if (other.hasId()) {
+ setId(other.getId());
+ }
+ if (other.hasPublicKey()) {
+ setPublicKey(other.getPublicKey());
+ }
+ if (other.hasPrivateKey()) {
+ setPrivateKey(other.getPrivateKey());
+ }
+ if (other.hasSignature()) {
+ setSignature(other.getSignature());
+ }
+ if (other.hasTimestamp()) {
+ setTimestamp(other.getTimestamp());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.state.StorageProtos.SignedPreKeyRecordStructure) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional uint32 id = 1;
+ private int id_ ;
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public boolean hasId() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public int getId() {
+ return id_;
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public Builder setId(int value) {
+ bitField0_ |= 0x00000001;
+ id_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 id = 1;</code>
+ */
+ public Builder clearId() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ id_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional bytes publicKey = 2;
+ private com.google.protobuf.ByteString publicKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes publicKey = 2;</code>
+ */
+ public boolean hasPublicKey() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes publicKey = 2;</code>
+ */
+ public com.google.protobuf.ByteString getPublicKey() {
+ return publicKey_;
+ }
+ /**
+ * <code>optional bytes publicKey = 2;</code>
+ */
+ public Builder setPublicKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000002;
+ publicKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes publicKey = 2;</code>
+ */
+ public Builder clearPublicKey() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ publicKey_ = getDefaultInstance().getPublicKey();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes privateKey = 3;
+ private com.google.protobuf.ByteString privateKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes privateKey = 3;</code>
+ */
+ public boolean hasPrivateKey() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional bytes privateKey = 3;</code>
+ */
+ public com.google.protobuf.ByteString getPrivateKey() {
+ return privateKey_;
+ }
+ /**
+ * <code>optional bytes privateKey = 3;</code>
+ */
+ public Builder setPrivateKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000004;
+ privateKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes privateKey = 3;</code>
+ */
+ public Builder clearPrivateKey() {
+ bitField0_ = (bitField0_ & ~0x00000004);
+ privateKey_ = getDefaultInstance().getPrivateKey();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes signature = 4;
+ private com.google.protobuf.ByteString signature_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes signature = 4;</code>
+ */
+ public boolean hasSignature() {
+ return ((bitField0_ & 0x00000008) == 0x00000008);
+ }
+ /**
+ * <code>optional bytes signature = 4;</code>
+ */
+ public com.google.protobuf.ByteString getSignature() {
+ return signature_;
+ }
+ /**
+ * <code>optional bytes signature = 4;</code>
+ */
+ public Builder setSignature(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000008;
+ signature_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes signature = 4;</code>
+ */
+ public Builder clearSignature() {
+ bitField0_ = (bitField0_ & ~0x00000008);
+ signature_ = getDefaultInstance().getSignature();
+ onChanged();
+ return this;
+ }
+
+ // optional fixed64 timestamp = 5;
+ private long timestamp_ ;
+ /**
+ * <code>optional fixed64 timestamp = 5;</code>
+ */
+ public boolean hasTimestamp() {
+ return ((bitField0_ & 0x00000010) == 0x00000010);
+ }
+ /**
+ * <code>optional fixed64 timestamp = 5;</code>
+ */
+ public long getTimestamp() {
+ return timestamp_;
+ }
+ /**
+ * <code>optional fixed64 timestamp = 5;</code>
+ */
+ public Builder setTimestamp(long value) {
+ bitField0_ |= 0x00000010;
+ timestamp_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional fixed64 timestamp = 5;</code>
+ */
+ public Builder clearTimestamp() {
+ bitField0_ = (bitField0_ & ~0x00000010);
+ timestamp_ = 0L;
+ onChanged();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.SignedPreKeyRecordStructure)
+ }
+
+ static {
+ defaultInstance = new SignedPreKeyRecordStructure(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.SignedPreKeyRecordStructure)
+ }
+
+ public interface IdentityKeyPairStructureOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional bytes publicKey = 1;
+ /**
+ * <code>optional bytes publicKey = 1;</code>
+ */
+ boolean hasPublicKey();
+ /**
+ * <code>optional bytes publicKey = 1;</code>
+ */
+ com.google.protobuf.ByteString getPublicKey();
+
+ // optional bytes privateKey = 2;
+ /**
+ * <code>optional bytes privateKey = 2;</code>
+ */
+ boolean hasPrivateKey();
+ /**
+ * <code>optional bytes privateKey = 2;</code>
+ */
+ com.google.protobuf.ByteString getPrivateKey();
+ }
+ /**
+ * Protobuf type {@code textsecure.IdentityKeyPairStructure}
+ */
+ public static final class IdentityKeyPairStructure extends
+ com.google.protobuf.GeneratedMessage
+ implements IdentityKeyPairStructureOrBuilder {
+ // Use IdentityKeyPairStructure.newBuilder() to construct.
+ private IdentityKeyPairStructure(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private IdentityKeyPairStructure(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final IdentityKeyPairStructure defaultInstance;
+ public static IdentityKeyPairStructure getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public IdentityKeyPairStructure getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private IdentityKeyPairStructure(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 10: {
+ bitField0_ |= 0x00000001;
+ publicKey_ = input.readBytes();
+ break;
+ }
+ case 18: {
+ bitField0_ |= 0x00000002;
+ privateKey_ = input.readBytes();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_IdentityKeyPairStructure_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_IdentityKeyPairStructure_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure.class, org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<IdentityKeyPairStructure> PARSER =
+ new com.google.protobuf.AbstractParser<IdentityKeyPairStructure>() {
+ public IdentityKeyPairStructure parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new IdentityKeyPairStructure(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<IdentityKeyPairStructure> getParserForType() {
+ return PARSER;
+ }
+
+ private int bitField0_;
+ // optional bytes publicKey = 1;
+ public static final int PUBLICKEY_FIELD_NUMBER = 1;
+ private com.google.protobuf.ByteString publicKey_;
+ /**
+ * <code>optional bytes publicKey = 1;</code>
+ */
+ public boolean hasPublicKey() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional bytes publicKey = 1;</code>
+ */
+ public com.google.protobuf.ByteString getPublicKey() {
+ return publicKey_;
+ }
+
+ // optional bytes privateKey = 2;
+ public static final int PRIVATEKEY_FIELD_NUMBER = 2;
+ private com.google.protobuf.ByteString privateKey_;
+ /**
+ * <code>optional bytes privateKey = 2;</code>
+ */
+ public boolean hasPrivateKey() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes privateKey = 2;</code>
+ */
+ public com.google.protobuf.ByteString getPrivateKey() {
+ return privateKey_;
+ }
+
+ private void initFields() {
+ publicKey_ = com.google.protobuf.ByteString.EMPTY;
+ privateKey_ = com.google.protobuf.ByteString.EMPTY;
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeBytes(1, publicKey_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeBytes(2, privateKey_);
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(1, publicKey_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(2, privateKey_);
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.IdentityKeyPairStructure}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructureOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_IdentityKeyPairStructure_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_IdentityKeyPairStructure_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure.class, org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ publicKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ privateKey_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_IdentityKeyPairStructure_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure build() {
+ org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure buildPartial() {
+ org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure result = new org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.publicKey_ = publicKey_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.privateKey_ = privateKey_;
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure) {
+ return mergeFrom((org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure other) {
+ if (other == org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure.getDefaultInstance()) return this;
+ if (other.hasPublicKey()) {
+ setPublicKey(other.getPublicKey());
+ }
+ if (other.hasPrivateKey()) {
+ setPrivateKey(other.getPrivateKey());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.state.StorageProtos.IdentityKeyPairStructure) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional bytes publicKey = 1;
+ private com.google.protobuf.ByteString publicKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes publicKey = 1;</code>
+ */
+ public boolean hasPublicKey() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional bytes publicKey = 1;</code>
+ */
+ public com.google.protobuf.ByteString getPublicKey() {
+ return publicKey_;
+ }
+ /**
+ * <code>optional bytes publicKey = 1;</code>
+ */
+ public Builder setPublicKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000001;
+ publicKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes publicKey = 1;</code>
+ */
+ public Builder clearPublicKey() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ publicKey_ = getDefaultInstance().getPublicKey();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes privateKey = 2;
+ private com.google.protobuf.ByteString privateKey_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes privateKey = 2;</code>
+ */
+ public boolean hasPrivateKey() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes privateKey = 2;</code>
+ */
+ public com.google.protobuf.ByteString getPrivateKey() {
+ return privateKey_;
+ }
+ /**
+ * <code>optional bytes privateKey = 2;</code>
+ */
+ public Builder setPrivateKey(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000002;
+ privateKey_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes privateKey = 2;</code>
+ */
+ public Builder clearPrivateKey() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ privateKey_ = getDefaultInstance().getPrivateKey();
+ onChanged();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.IdentityKeyPairStructure)
+ }
+
+ static {
+ defaultInstance = new IdentityKeyPairStructure(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.IdentityKeyPairStructure)
+ }
+
+ public interface SenderKeyStateStructureOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional uint32 senderKeyId = 1;
+ /**
+ * <code>optional uint32 senderKeyId = 1;</code>
+ */
+ boolean hasSenderKeyId();
+ /**
+ * <code>optional uint32 senderKeyId = 1;</code>
+ */
+ int getSenderKeyId();
+
+ // optional .textsecure.SenderKeyStateStructure.SenderChainKey senderChainKey = 2;
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderChainKey senderChainKey = 2;</code>
+ */
+ boolean hasSenderChainKey();
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderChainKey senderChainKey = 2;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey getSenderChainKey();
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderChainKey senderChainKey = 2;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKeyOrBuilder getSenderChainKeyOrBuilder();
+
+ // optional .textsecure.SenderKeyStateStructure.SenderSigningKey senderSigningKey = 3;
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderSigningKey senderSigningKey = 3;</code>
+ */
+ boolean hasSenderSigningKey();
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderSigningKey senderSigningKey = 3;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey getSenderSigningKey();
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderSigningKey senderSigningKey = 3;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKeyOrBuilder getSenderSigningKeyOrBuilder();
+
+ // repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey>
+ getSenderMessageKeysList();
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey getSenderMessageKeys(int index);
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ int getSenderMessageKeysCount();
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ java.util.List<? extends org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKeyOrBuilder>
+ getSenderMessageKeysOrBuilderList();
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKeyOrBuilder getSenderMessageKeysOrBuilder(
+ int index);
+ }
+ /**
+ * Protobuf type {@code textsecure.SenderKeyStateStructure}
+ */
+ public static final class SenderKeyStateStructure extends
+ com.google.protobuf.GeneratedMessage
+ implements SenderKeyStateStructureOrBuilder {
+ // Use SenderKeyStateStructure.newBuilder() to construct.
+ private SenderKeyStateStructure(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private SenderKeyStateStructure(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final SenderKeyStateStructure defaultInstance;
+ public static SenderKeyStateStructure getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public SenderKeyStateStructure getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private SenderKeyStateStructure(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 8: {
+ bitField0_ |= 0x00000001;
+ senderKeyId_ = input.readUInt32();
+ break;
+ }
+ case 18: {
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.Builder subBuilder = null;
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ subBuilder = senderChainKey_.toBuilder();
+ }
+ senderChainKey_ = input.readMessage(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.PARSER, extensionRegistry);
+ if (subBuilder != null) {
+ subBuilder.mergeFrom(senderChainKey_);
+ senderChainKey_ = subBuilder.buildPartial();
+ }
+ bitField0_ |= 0x00000002;
+ break;
+ }
+ case 26: {
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.Builder subBuilder = null;
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ subBuilder = senderSigningKey_.toBuilder();
+ }
+ senderSigningKey_ = input.readMessage(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.PARSER, extensionRegistry);
+ if (subBuilder != null) {
+ subBuilder.mergeFrom(senderSigningKey_);
+ senderSigningKey_ = subBuilder.buildPartial();
+ }
+ bitField0_ |= 0x00000004;
+ break;
+ }
+ case 34: {
+ if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
+ senderMessageKeys_ = new java.util.ArrayList<org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey>();
+ mutable_bitField0_ |= 0x00000008;
+ }
+ senderMessageKeys_.add(input.readMessage(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.PARSER, extensionRegistry));
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
+ senderMessageKeys_ = java.util.Collections.unmodifiableList(senderMessageKeys_);
+ }
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.class, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<SenderKeyStateStructure> PARSER =
+ new com.google.protobuf.AbstractParser<SenderKeyStateStructure>() {
+ public SenderKeyStateStructure parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new SenderKeyStateStructure(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<SenderKeyStateStructure> getParserForType() {
+ return PARSER;
+ }
+
+ public interface SenderChainKeyOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional uint32 iteration = 1;
+ /**
+ * <code>optional uint32 iteration = 1;</code>
+ */
+ boolean hasIteration();
+ /**
+ * <code>optional uint32 iteration = 1;</code>
+ */
+ int getIteration();
+
+ // optional bytes seed = 2;
+ /**
+ * <code>optional bytes seed = 2;</code>
+ */
+ boolean hasSeed();
+ /**
+ * <code>optional bytes seed = 2;</code>
+ */
+ com.google.protobuf.ByteString getSeed();
+ }
+ /**
+ * Protobuf type {@code textsecure.SenderKeyStateStructure.SenderChainKey}
+ */
+ public static final class SenderChainKey extends
+ com.google.protobuf.GeneratedMessage
+ implements SenderChainKeyOrBuilder {
+ // Use SenderChainKey.newBuilder() to construct.
+ private SenderChainKey(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private SenderChainKey(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final SenderChainKey defaultInstance;
+ public static SenderChainKey getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public SenderChainKey getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private SenderChainKey(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 8: {
+ bitField0_ |= 0x00000001;
+ iteration_ = input.readUInt32();
+ break;
+ }
+ case 18: {
+ bitField0_ |= 0x00000002;
+ seed_ = input.readBytes();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_SenderChainKey_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_SenderChainKey_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.class, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<SenderChainKey> PARSER =
+ new com.google.protobuf.AbstractParser<SenderChainKey>() {
+ public SenderChainKey parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new SenderChainKey(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<SenderChainKey> getParserForType() {
+ return PARSER;
+ }
+
+ private int bitField0_;
+ // optional uint32 iteration = 1;
+ public static final int ITERATION_FIELD_NUMBER = 1;
+ private int iteration_;
+ /**
+ * <code>optional uint32 iteration = 1;</code>
+ */
+ public boolean hasIteration() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 iteration = 1;</code>
+ */
+ public int getIteration() {
+ return iteration_;
+ }
+
+ // optional bytes seed = 2;
+ public static final int SEED_FIELD_NUMBER = 2;
+ private com.google.protobuf.ByteString seed_;
+ /**
+ * <code>optional bytes seed = 2;</code>
+ */
+ public boolean hasSeed() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes seed = 2;</code>
+ */
+ public com.google.protobuf.ByteString getSeed() {
+ return seed_;
+ }
+
+ private void initFields() {
+ iteration_ = 0;
+ seed_ = com.google.protobuf.ByteString.EMPTY;
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeUInt32(1, iteration_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeBytes(2, seed_);
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(1, iteration_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(2, seed_);
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.SenderKeyStateStructure.SenderChainKey}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKeyOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_SenderChainKey_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_SenderChainKey_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.class, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ iteration_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ seed_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_SenderChainKey_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey build() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey buildPartial() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey result = new org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.iteration_ = iteration_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.seed_ = seed_;
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey) {
+ return mergeFrom((org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey other) {
+ if (other == org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.getDefaultInstance()) return this;
+ if (other.hasIteration()) {
+ setIteration(other.getIteration());
+ }
+ if (other.hasSeed()) {
+ setSeed(other.getSeed());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional uint32 iteration = 1;
+ private int iteration_ ;
+ /**
+ * <code>optional uint32 iteration = 1;</code>
+ */
+ public boolean hasIteration() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 iteration = 1;</code>
+ */
+ public int getIteration() {
+ return iteration_;
+ }
+ /**
+ * <code>optional uint32 iteration = 1;</code>
+ */
+ public Builder setIteration(int value) {
+ bitField0_ |= 0x00000001;
+ iteration_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 iteration = 1;</code>
+ */
+ public Builder clearIteration() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ iteration_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional bytes seed = 2;
+ private com.google.protobuf.ByteString seed_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes seed = 2;</code>
+ */
+ public boolean hasSeed() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes seed = 2;</code>
+ */
+ public com.google.protobuf.ByteString getSeed() {
+ return seed_;
+ }
+ /**
+ * <code>optional bytes seed = 2;</code>
+ */
+ public Builder setSeed(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000002;
+ seed_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes seed = 2;</code>
+ */
+ public Builder clearSeed() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ seed_ = getDefaultInstance().getSeed();
+ onChanged();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.SenderKeyStateStructure.SenderChainKey)
+ }
+
+ static {
+ defaultInstance = new SenderChainKey(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.SenderKeyStateStructure.SenderChainKey)
+ }
+
+ public interface SenderMessageKeyOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional uint32 iteration = 1;
+ /**
+ * <code>optional uint32 iteration = 1;</code>
+ */
+ boolean hasIteration();
+ /**
+ * <code>optional uint32 iteration = 1;</code>
+ */
+ int getIteration();
+
+ // optional bytes seed = 2;
+ /**
+ * <code>optional bytes seed = 2;</code>
+ */
+ boolean hasSeed();
+ /**
+ * <code>optional bytes seed = 2;</code>
+ */
+ com.google.protobuf.ByteString getSeed();
+ }
+ /**
+ * Protobuf type {@code textsecure.SenderKeyStateStructure.SenderMessageKey}
+ */
+ public static final class SenderMessageKey extends
+ com.google.protobuf.GeneratedMessage
+ implements SenderMessageKeyOrBuilder {
+ // Use SenderMessageKey.newBuilder() to construct.
+ private SenderMessageKey(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private SenderMessageKey(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final SenderMessageKey defaultInstance;
+ public static SenderMessageKey getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public SenderMessageKey getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private SenderMessageKey(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 8: {
+ bitField0_ |= 0x00000001;
+ iteration_ = input.readUInt32();
+ break;
+ }
+ case 18: {
+ bitField0_ |= 0x00000002;
+ seed_ = input.readBytes();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_SenderMessageKey_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_SenderMessageKey_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.class, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<SenderMessageKey> PARSER =
+ new com.google.protobuf.AbstractParser<SenderMessageKey>() {
+ public SenderMessageKey parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new SenderMessageKey(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<SenderMessageKey> getParserForType() {
+ return PARSER;
+ }
+
+ private int bitField0_;
+ // optional uint32 iteration = 1;
+ public static final int ITERATION_FIELD_NUMBER = 1;
+ private int iteration_;
+ /**
+ * <code>optional uint32 iteration = 1;</code>
+ */
+ public boolean hasIteration() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 iteration = 1;</code>
+ */
+ public int getIteration() {
+ return iteration_;
+ }
+
+ // optional bytes seed = 2;
+ public static final int SEED_FIELD_NUMBER = 2;
+ private com.google.protobuf.ByteString seed_;
+ /**
+ * <code>optional bytes seed = 2;</code>
+ */
+ public boolean hasSeed() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes seed = 2;</code>
+ */
+ public com.google.protobuf.ByteString getSeed() {
+ return seed_;
+ }
+
+ private void initFields() {
+ iteration_ = 0;
+ seed_ = com.google.protobuf.ByteString.EMPTY;
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeUInt32(1, iteration_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeBytes(2, seed_);
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(1, iteration_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(2, seed_);
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.SenderKeyStateStructure.SenderMessageKey}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKeyOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_SenderMessageKey_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_SenderMessageKey_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.class, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ iteration_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ seed_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_SenderMessageKey_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey build() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey buildPartial() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey result = new org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.iteration_ = iteration_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.seed_ = seed_;
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey) {
+ return mergeFrom((org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey other) {
+ if (other == org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.getDefaultInstance()) return this;
+ if (other.hasIteration()) {
+ setIteration(other.getIteration());
+ }
+ if (other.hasSeed()) {
+ setSeed(other.getSeed());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional uint32 iteration = 1;
+ private int iteration_ ;
+ /**
+ * <code>optional uint32 iteration = 1;</code>
+ */
+ public boolean hasIteration() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 iteration = 1;</code>
+ */
+ public int getIteration() {
+ return iteration_;
+ }
+ /**
+ * <code>optional uint32 iteration = 1;</code>
+ */
+ public Builder setIteration(int value) {
+ bitField0_ |= 0x00000001;
+ iteration_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 iteration = 1;</code>
+ */
+ public Builder clearIteration() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ iteration_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional bytes seed = 2;
+ private com.google.protobuf.ByteString seed_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes seed = 2;</code>
+ */
+ public boolean hasSeed() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes seed = 2;</code>
+ */
+ public com.google.protobuf.ByteString getSeed() {
+ return seed_;
+ }
+ /**
+ * <code>optional bytes seed = 2;</code>
+ */
+ public Builder setSeed(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000002;
+ seed_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes seed = 2;</code>
+ */
+ public Builder clearSeed() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ seed_ = getDefaultInstance().getSeed();
+ onChanged();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.SenderKeyStateStructure.SenderMessageKey)
+ }
+
+ static {
+ defaultInstance = new SenderMessageKey(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.SenderKeyStateStructure.SenderMessageKey)
+ }
+
+ public interface SenderSigningKeyOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // optional bytes public = 1;
+ /**
+ * <code>optional bytes public = 1;</code>
+ */
+ boolean hasPublic();
+ /**
+ * <code>optional bytes public = 1;</code>
+ */
+ com.google.protobuf.ByteString getPublic();
+
+ // optional bytes private = 2;
+ /**
+ * <code>optional bytes private = 2;</code>
+ */
+ boolean hasPrivate();
+ /**
+ * <code>optional bytes private = 2;</code>
+ */
+ com.google.protobuf.ByteString getPrivate();
+ }
+ /**
+ * Protobuf type {@code textsecure.SenderKeyStateStructure.SenderSigningKey}
+ */
+ public static final class SenderSigningKey extends
+ com.google.protobuf.GeneratedMessage
+ implements SenderSigningKeyOrBuilder {
+ // Use SenderSigningKey.newBuilder() to construct.
+ private SenderSigningKey(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private SenderSigningKey(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final SenderSigningKey defaultInstance;
+ public static SenderSigningKey getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public SenderSigningKey getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private SenderSigningKey(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 10: {
+ bitField0_ |= 0x00000001;
+ public_ = input.readBytes();
+ break;
+ }
+ case 18: {
+ bitField0_ |= 0x00000002;
+ private_ = input.readBytes();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_SenderSigningKey_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_SenderSigningKey_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.class, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<SenderSigningKey> PARSER =
+ new com.google.protobuf.AbstractParser<SenderSigningKey>() {
+ public SenderSigningKey parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new SenderSigningKey(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<SenderSigningKey> getParserForType() {
+ return PARSER;
+ }
+
+ private int bitField0_;
+ // optional bytes public = 1;
+ public static final int PUBLIC_FIELD_NUMBER = 1;
+ private com.google.protobuf.ByteString public_;
+ /**
+ * <code>optional bytes public = 1;</code>
+ */
+ public boolean hasPublic() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional bytes public = 1;</code>
+ */
+ public com.google.protobuf.ByteString getPublic() {
+ return public_;
+ }
+
+ // optional bytes private = 2;
+ public static final int PRIVATE_FIELD_NUMBER = 2;
+ private com.google.protobuf.ByteString private_;
+ /**
+ * <code>optional bytes private = 2;</code>
+ */
+ public boolean hasPrivate() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes private = 2;</code>
+ */
+ public com.google.protobuf.ByteString getPrivate() {
+ return private_;
+ }
+
+ private void initFields() {
+ public_ = com.google.protobuf.ByteString.EMPTY;
+ private_ = com.google.protobuf.ByteString.EMPTY;
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeBytes(1, public_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeBytes(2, private_);
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(1, public_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(2, private_);
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.SenderKeyStateStructure.SenderSigningKey}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKeyOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_SenderSigningKey_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_SenderSigningKey_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.class, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ public_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ private_ = com.google.protobuf.ByteString.EMPTY;
+ bitField0_ = (bitField0_ & ~0x00000002);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_SenderSigningKey_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey build() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey buildPartial() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey result = new org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.public_ = public_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ result.private_ = private_;
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey) {
+ return mergeFrom((org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey other) {
+ if (other == org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.getDefaultInstance()) return this;
+ if (other.hasPublic()) {
+ setPublic(other.getPublic());
+ }
+ if (other.hasPrivate()) {
+ setPrivate(other.getPrivate());
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional bytes public = 1;
+ private com.google.protobuf.ByteString public_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes public = 1;</code>
+ */
+ public boolean hasPublic() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional bytes public = 1;</code>
+ */
+ public com.google.protobuf.ByteString getPublic() {
+ return public_;
+ }
+ /**
+ * <code>optional bytes public = 1;</code>
+ */
+ public Builder setPublic(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000001;
+ public_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes public = 1;</code>
+ */
+ public Builder clearPublic() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ public_ = getDefaultInstance().getPublic();
+ onChanged();
+ return this;
+ }
+
+ // optional bytes private = 2;
+ private com.google.protobuf.ByteString private_ = com.google.protobuf.ByteString.EMPTY;
+ /**
+ * <code>optional bytes private = 2;</code>
+ */
+ public boolean hasPrivate() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional bytes private = 2;</code>
+ */
+ public com.google.protobuf.ByteString getPrivate() {
+ return private_;
+ }
+ /**
+ * <code>optional bytes private = 2;</code>
+ */
+ public Builder setPrivate(com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000002;
+ private_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional bytes private = 2;</code>
+ */
+ public Builder clearPrivate() {
+ bitField0_ = (bitField0_ & ~0x00000002);
+ private_ = getDefaultInstance().getPrivate();
+ onChanged();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.SenderKeyStateStructure.SenderSigningKey)
+ }
+
+ static {
+ defaultInstance = new SenderSigningKey(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.SenderKeyStateStructure.SenderSigningKey)
+ }
+
+ private int bitField0_;
+ // optional uint32 senderKeyId = 1;
+ public static final int SENDERKEYID_FIELD_NUMBER = 1;
+ private int senderKeyId_;
+ /**
+ * <code>optional uint32 senderKeyId = 1;</code>
+ */
+ public boolean hasSenderKeyId() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 senderKeyId = 1;</code>
+ */
+ public int getSenderKeyId() {
+ return senderKeyId_;
+ }
+
+ // optional .textsecure.SenderKeyStateStructure.SenderChainKey senderChainKey = 2;
+ public static final int SENDERCHAINKEY_FIELD_NUMBER = 2;
+ private org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey senderChainKey_;
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderChainKey senderChainKey = 2;</code>
+ */
+ public boolean hasSenderChainKey() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderChainKey senderChainKey = 2;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey getSenderChainKey() {
+ return senderChainKey_;
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderChainKey senderChainKey = 2;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKeyOrBuilder getSenderChainKeyOrBuilder() {
+ return senderChainKey_;
+ }
+
+ // optional .textsecure.SenderKeyStateStructure.SenderSigningKey senderSigningKey = 3;
+ public static final int SENDERSIGNINGKEY_FIELD_NUMBER = 3;
+ private org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey senderSigningKey_;
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderSigningKey senderSigningKey = 3;</code>
+ */
+ public boolean hasSenderSigningKey() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderSigningKey senderSigningKey = 3;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey getSenderSigningKey() {
+ return senderSigningKey_;
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderSigningKey senderSigningKey = 3;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKeyOrBuilder getSenderSigningKeyOrBuilder() {
+ return senderSigningKey_;
+ }
+
+ // repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;
+ public static final int SENDERMESSAGEKEYS_FIELD_NUMBER = 4;
+ private java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey> senderMessageKeys_;
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey> getSenderMessageKeysList() {
+ return senderMessageKeys_;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public java.util.List<? extends org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKeyOrBuilder>
+ getSenderMessageKeysOrBuilderList() {
+ return senderMessageKeys_;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public int getSenderMessageKeysCount() {
+ return senderMessageKeys_.size();
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey getSenderMessageKeys(int index) {
+ return senderMessageKeys_.get(index);
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKeyOrBuilder getSenderMessageKeysOrBuilder(
+ int index) {
+ return senderMessageKeys_.get(index);
+ }
+
+ private void initFields() {
+ senderKeyId_ = 0;
+ senderChainKey_ = org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.getDefaultInstance();
+ senderSigningKey_ = org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.getDefaultInstance();
+ senderMessageKeys_ = java.util.Collections.emptyList();
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeUInt32(1, senderKeyId_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ output.writeMessage(2, senderChainKey_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ output.writeMessage(3, senderSigningKey_);
+ }
+ for (int i = 0; i < senderMessageKeys_.size(); i++) {
+ output.writeMessage(4, senderMessageKeys_.get(i));
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeUInt32Size(1, senderKeyId_);
+ }
+ if (((bitField0_ & 0x00000002) == 0x00000002)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeMessageSize(2, senderChainKey_);
+ }
+ if (((bitField0_ & 0x00000004) == 0x00000004)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeMessageSize(3, senderSigningKey_);
+ }
+ for (int i = 0; i < senderMessageKeys_.size(); i++) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeMessageSize(4, senderMessageKeys_.get(i));
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.SenderKeyStateStructure}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructureOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.class, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ getSenderChainKeyFieldBuilder();
+ getSenderSigningKeyFieldBuilder();
+ getSenderMessageKeysFieldBuilder();
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ senderKeyId_ = 0;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ if (senderChainKeyBuilder_ == null) {
+ senderChainKey_ = org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.getDefaultInstance();
+ } else {
+ senderChainKeyBuilder_.clear();
+ }
+ bitField0_ = (bitField0_ & ~0x00000002);
+ if (senderSigningKeyBuilder_ == null) {
+ senderSigningKey_ = org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.getDefaultInstance();
+ } else {
+ senderSigningKeyBuilder_.clear();
+ }
+ bitField0_ = (bitField0_ & ~0x00000004);
+ if (senderMessageKeysBuilder_ == null) {
+ senderMessageKeys_ = java.util.Collections.emptyList();
+ bitField0_ = (bitField0_ & ~0x00000008);
+ } else {
+ senderMessageKeysBuilder_.clear();
+ }
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyStateStructure_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure build() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure buildPartial() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure result = new org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.senderKeyId_ = senderKeyId_;
+ if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+ to_bitField0_ |= 0x00000002;
+ }
+ if (senderChainKeyBuilder_ == null) {
+ result.senderChainKey_ = senderChainKey_;
+ } else {
+ result.senderChainKey_ = senderChainKeyBuilder_.build();
+ }
+ if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+ to_bitField0_ |= 0x00000004;
+ }
+ if (senderSigningKeyBuilder_ == null) {
+ result.senderSigningKey_ = senderSigningKey_;
+ } else {
+ result.senderSigningKey_ = senderSigningKeyBuilder_.build();
+ }
+ if (senderMessageKeysBuilder_ == null) {
+ if (((bitField0_ & 0x00000008) == 0x00000008)) {
+ senderMessageKeys_ = java.util.Collections.unmodifiableList(senderMessageKeys_);
+ bitField0_ = (bitField0_ & ~0x00000008);
+ }
+ result.senderMessageKeys_ = senderMessageKeys_;
+ } else {
+ result.senderMessageKeys_ = senderMessageKeysBuilder_.build();
+ }
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure) {
+ return mergeFrom((org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure other) {
+ if (other == org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.getDefaultInstance()) return this;
+ if (other.hasSenderKeyId()) {
+ setSenderKeyId(other.getSenderKeyId());
+ }
+ if (other.hasSenderChainKey()) {
+ mergeSenderChainKey(other.getSenderChainKey());
+ }
+ if (other.hasSenderSigningKey()) {
+ mergeSenderSigningKey(other.getSenderSigningKey());
+ }
+ if (senderMessageKeysBuilder_ == null) {
+ if (!other.senderMessageKeys_.isEmpty()) {
+ if (senderMessageKeys_.isEmpty()) {
+ senderMessageKeys_ = other.senderMessageKeys_;
+ bitField0_ = (bitField0_ & ~0x00000008);
+ } else {
+ ensureSenderMessageKeysIsMutable();
+ senderMessageKeys_.addAll(other.senderMessageKeys_);
+ }
+ onChanged();
+ }
+ } else {
+ if (!other.senderMessageKeys_.isEmpty()) {
+ if (senderMessageKeysBuilder_.isEmpty()) {
+ senderMessageKeysBuilder_.dispose();
+ senderMessageKeysBuilder_ = null;
+ senderMessageKeys_ = other.senderMessageKeys_;
+ bitField0_ = (bitField0_ & ~0x00000008);
+ senderMessageKeysBuilder_ =
+ com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
+ getSenderMessageKeysFieldBuilder() : null;
+ } else {
+ senderMessageKeysBuilder_.addAllMessages(other.senderMessageKeys_);
+ }
+ }
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // optional uint32 senderKeyId = 1;
+ private int senderKeyId_ ;
+ /**
+ * <code>optional uint32 senderKeyId = 1;</code>
+ */
+ public boolean hasSenderKeyId() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>optional uint32 senderKeyId = 1;</code>
+ */
+ public int getSenderKeyId() {
+ return senderKeyId_;
+ }
+ /**
+ * <code>optional uint32 senderKeyId = 1;</code>
+ */
+ public Builder setSenderKeyId(int value) {
+ bitField0_ |= 0x00000001;
+ senderKeyId_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>optional uint32 senderKeyId = 1;</code>
+ */
+ public Builder clearSenderKeyId() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ senderKeyId_ = 0;
+ onChanged();
+ return this;
+ }
+
+ // optional .textsecure.SenderKeyStateStructure.SenderChainKey senderChainKey = 2;
+ private org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey senderChainKey_ = org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.getDefaultInstance();
+ private com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKeyOrBuilder> senderChainKeyBuilder_;
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderChainKey senderChainKey = 2;</code>
+ */
+ public boolean hasSenderChainKey() {
+ return ((bitField0_ & 0x00000002) == 0x00000002);
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderChainKey senderChainKey = 2;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey getSenderChainKey() {
+ if (senderChainKeyBuilder_ == null) {
+ return senderChainKey_;
+ } else {
+ return senderChainKeyBuilder_.getMessage();
+ }
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderChainKey senderChainKey = 2;</code>
+ */
+ public Builder setSenderChainKey(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey value) {
+ if (senderChainKeyBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ senderChainKey_ = value;
+ onChanged();
+ } else {
+ senderChainKeyBuilder_.setMessage(value);
+ }
+ bitField0_ |= 0x00000002;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderChainKey senderChainKey = 2;</code>
+ */
+ public Builder setSenderChainKey(
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.Builder builderForValue) {
+ if (senderChainKeyBuilder_ == null) {
+ senderChainKey_ = builderForValue.build();
+ onChanged();
+ } else {
+ senderChainKeyBuilder_.setMessage(builderForValue.build());
+ }
+ bitField0_ |= 0x00000002;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderChainKey senderChainKey = 2;</code>
+ */
+ public Builder mergeSenderChainKey(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey value) {
+ if (senderChainKeyBuilder_ == null) {
+ if (((bitField0_ & 0x00000002) == 0x00000002) &&
+ senderChainKey_ != org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.getDefaultInstance()) {
+ senderChainKey_ =
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.newBuilder(senderChainKey_).mergeFrom(value).buildPartial();
+ } else {
+ senderChainKey_ = value;
+ }
+ onChanged();
+ } else {
+ senderChainKeyBuilder_.mergeFrom(value);
+ }
+ bitField0_ |= 0x00000002;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderChainKey senderChainKey = 2;</code>
+ */
+ public Builder clearSenderChainKey() {
+ if (senderChainKeyBuilder_ == null) {
+ senderChainKey_ = org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.getDefaultInstance();
+ onChanged();
+ } else {
+ senderChainKeyBuilder_.clear();
+ }
+ bitField0_ = (bitField0_ & ~0x00000002);
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderChainKey senderChainKey = 2;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.Builder getSenderChainKeyBuilder() {
+ bitField0_ |= 0x00000002;
+ onChanged();
+ return getSenderChainKeyFieldBuilder().getBuilder();
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderChainKey senderChainKey = 2;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKeyOrBuilder getSenderChainKeyOrBuilder() {
+ if (senderChainKeyBuilder_ != null) {
+ return senderChainKeyBuilder_.getMessageOrBuilder();
+ } else {
+ return senderChainKey_;
+ }
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderChainKey senderChainKey = 2;</code>
+ */
+ private com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKeyOrBuilder>
+ getSenderChainKeyFieldBuilder() {
+ if (senderChainKeyBuilder_ == null) {
+ senderChainKeyBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKey.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderChainKeyOrBuilder>(
+ senderChainKey_,
+ getParentForChildren(),
+ isClean());
+ senderChainKey_ = null;
+ }
+ return senderChainKeyBuilder_;
+ }
+
+ // optional .textsecure.SenderKeyStateStructure.SenderSigningKey senderSigningKey = 3;
+ private org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey senderSigningKey_ = org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.getDefaultInstance();
+ private com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKeyOrBuilder> senderSigningKeyBuilder_;
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderSigningKey senderSigningKey = 3;</code>
+ */
+ public boolean hasSenderSigningKey() {
+ return ((bitField0_ & 0x00000004) == 0x00000004);
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderSigningKey senderSigningKey = 3;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey getSenderSigningKey() {
+ if (senderSigningKeyBuilder_ == null) {
+ return senderSigningKey_;
+ } else {
+ return senderSigningKeyBuilder_.getMessage();
+ }
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderSigningKey senderSigningKey = 3;</code>
+ */
+ public Builder setSenderSigningKey(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey value) {
+ if (senderSigningKeyBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ senderSigningKey_ = value;
+ onChanged();
+ } else {
+ senderSigningKeyBuilder_.setMessage(value);
+ }
+ bitField0_ |= 0x00000004;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderSigningKey senderSigningKey = 3;</code>
+ */
+ public Builder setSenderSigningKey(
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.Builder builderForValue) {
+ if (senderSigningKeyBuilder_ == null) {
+ senderSigningKey_ = builderForValue.build();
+ onChanged();
+ } else {
+ senderSigningKeyBuilder_.setMessage(builderForValue.build());
+ }
+ bitField0_ |= 0x00000004;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderSigningKey senderSigningKey = 3;</code>
+ */
+ public Builder mergeSenderSigningKey(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey value) {
+ if (senderSigningKeyBuilder_ == null) {
+ if (((bitField0_ & 0x00000004) == 0x00000004) &&
+ senderSigningKey_ != org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.getDefaultInstance()) {
+ senderSigningKey_ =
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.newBuilder(senderSigningKey_).mergeFrom(value).buildPartial();
+ } else {
+ senderSigningKey_ = value;
+ }
+ onChanged();
+ } else {
+ senderSigningKeyBuilder_.mergeFrom(value);
+ }
+ bitField0_ |= 0x00000004;
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderSigningKey senderSigningKey = 3;</code>
+ */
+ public Builder clearSenderSigningKey() {
+ if (senderSigningKeyBuilder_ == null) {
+ senderSigningKey_ = org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.getDefaultInstance();
+ onChanged();
+ } else {
+ senderSigningKeyBuilder_.clear();
+ }
+ bitField0_ = (bitField0_ & ~0x00000004);
+ return this;
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderSigningKey senderSigningKey = 3;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.Builder getSenderSigningKeyBuilder() {
+ bitField0_ |= 0x00000004;
+ onChanged();
+ return getSenderSigningKeyFieldBuilder().getBuilder();
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderSigningKey senderSigningKey = 3;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKeyOrBuilder getSenderSigningKeyOrBuilder() {
+ if (senderSigningKeyBuilder_ != null) {
+ return senderSigningKeyBuilder_.getMessageOrBuilder();
+ } else {
+ return senderSigningKey_;
+ }
+ }
+ /**
+ * <code>optional .textsecure.SenderKeyStateStructure.SenderSigningKey senderSigningKey = 3;</code>
+ */
+ private com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKeyOrBuilder>
+ getSenderSigningKeyFieldBuilder() {
+ if (senderSigningKeyBuilder_ == null) {
+ senderSigningKeyBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKey.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderSigningKeyOrBuilder>(
+ senderSigningKey_,
+ getParentForChildren(),
+ isClean());
+ senderSigningKey_ = null;
+ }
+ return senderSigningKeyBuilder_;
+ }
+
+ // repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;
+ private java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey> senderMessageKeys_ =
+ java.util.Collections.emptyList();
+ private void ensureSenderMessageKeysIsMutable() {
+ if (!((bitField0_ & 0x00000008) == 0x00000008)) {
+ senderMessageKeys_ = new java.util.ArrayList<org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey>(senderMessageKeys_);
+ bitField0_ |= 0x00000008;
+ }
+ }
+
+ private com.google.protobuf.RepeatedFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKeyOrBuilder> senderMessageKeysBuilder_;
+
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey> getSenderMessageKeysList() {
+ if (senderMessageKeysBuilder_ == null) {
+ return java.util.Collections.unmodifiableList(senderMessageKeys_);
+ } else {
+ return senderMessageKeysBuilder_.getMessageList();
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public int getSenderMessageKeysCount() {
+ if (senderMessageKeysBuilder_ == null) {
+ return senderMessageKeys_.size();
+ } else {
+ return senderMessageKeysBuilder_.getCount();
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey getSenderMessageKeys(int index) {
+ if (senderMessageKeysBuilder_ == null) {
+ return senderMessageKeys_.get(index);
+ } else {
+ return senderMessageKeysBuilder_.getMessage(index);
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public Builder setSenderMessageKeys(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey value) {
+ if (senderMessageKeysBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureSenderMessageKeysIsMutable();
+ senderMessageKeys_.set(index, value);
+ onChanged();
+ } else {
+ senderMessageKeysBuilder_.setMessage(index, value);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public Builder setSenderMessageKeys(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.Builder builderForValue) {
+ if (senderMessageKeysBuilder_ == null) {
+ ensureSenderMessageKeysIsMutable();
+ senderMessageKeys_.set(index, builderForValue.build());
+ onChanged();
+ } else {
+ senderMessageKeysBuilder_.setMessage(index, builderForValue.build());
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public Builder addSenderMessageKeys(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey value) {
+ if (senderMessageKeysBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureSenderMessageKeysIsMutable();
+ senderMessageKeys_.add(value);
+ onChanged();
+ } else {
+ senderMessageKeysBuilder_.addMessage(value);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public Builder addSenderMessageKeys(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey value) {
+ if (senderMessageKeysBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureSenderMessageKeysIsMutable();
+ senderMessageKeys_.add(index, value);
+ onChanged();
+ } else {
+ senderMessageKeysBuilder_.addMessage(index, value);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public Builder addSenderMessageKeys(
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.Builder builderForValue) {
+ if (senderMessageKeysBuilder_ == null) {
+ ensureSenderMessageKeysIsMutable();
+ senderMessageKeys_.add(builderForValue.build());
+ onChanged();
+ } else {
+ senderMessageKeysBuilder_.addMessage(builderForValue.build());
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public Builder addSenderMessageKeys(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.Builder builderForValue) {
+ if (senderMessageKeysBuilder_ == null) {
+ ensureSenderMessageKeysIsMutable();
+ senderMessageKeys_.add(index, builderForValue.build());
+ onChanged();
+ } else {
+ senderMessageKeysBuilder_.addMessage(index, builderForValue.build());
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public Builder addAllSenderMessageKeys(
+ java.lang.Iterable<? extends org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey> values) {
+ if (senderMessageKeysBuilder_ == null) {
+ ensureSenderMessageKeysIsMutable();
+ super.addAll(values, senderMessageKeys_);
+ onChanged();
+ } else {
+ senderMessageKeysBuilder_.addAllMessages(values);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public Builder clearSenderMessageKeys() {
+ if (senderMessageKeysBuilder_ == null) {
+ senderMessageKeys_ = java.util.Collections.emptyList();
+ bitField0_ = (bitField0_ & ~0x00000008);
+ onChanged();
+ } else {
+ senderMessageKeysBuilder_.clear();
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public Builder removeSenderMessageKeys(int index) {
+ if (senderMessageKeysBuilder_ == null) {
+ ensureSenderMessageKeysIsMutable();
+ senderMessageKeys_.remove(index);
+ onChanged();
+ } else {
+ senderMessageKeysBuilder_.remove(index);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.Builder getSenderMessageKeysBuilder(
+ int index) {
+ return getSenderMessageKeysFieldBuilder().getBuilder(index);
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKeyOrBuilder getSenderMessageKeysOrBuilder(
+ int index) {
+ if (senderMessageKeysBuilder_ == null) {
+ return senderMessageKeys_.get(index); } else {
+ return senderMessageKeysBuilder_.getMessageOrBuilder(index);
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public java.util.List<? extends org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKeyOrBuilder>
+ getSenderMessageKeysOrBuilderList() {
+ if (senderMessageKeysBuilder_ != null) {
+ return senderMessageKeysBuilder_.getMessageOrBuilderList();
+ } else {
+ return java.util.Collections.unmodifiableList(senderMessageKeys_);
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.Builder addSenderMessageKeysBuilder() {
+ return getSenderMessageKeysFieldBuilder().addBuilder(
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.getDefaultInstance());
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.Builder addSenderMessageKeysBuilder(
+ int index) {
+ return getSenderMessageKeysFieldBuilder().addBuilder(
+ index, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.getDefaultInstance());
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure.SenderMessageKey senderMessageKeys = 4;</code>
+ */
+ public java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.Builder>
+ getSenderMessageKeysBuilderList() {
+ return getSenderMessageKeysFieldBuilder().getBuilderList();
+ }
+ private com.google.protobuf.RepeatedFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKeyOrBuilder>
+ getSenderMessageKeysFieldBuilder() {
+ if (senderMessageKeysBuilder_ == null) {
+ senderMessageKeysBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKey.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.SenderMessageKeyOrBuilder>(
+ senderMessageKeys_,
+ ((bitField0_ & 0x00000008) == 0x00000008),
+ getParentForChildren(),
+ isClean());
+ senderMessageKeys_ = null;
+ }
+ return senderMessageKeysBuilder_;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.SenderKeyStateStructure)
+ }
+
+ static {
+ defaultInstance = new SenderKeyStateStructure(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.SenderKeyStateStructure)
+ }
+
+ public interface SenderKeyRecordStructureOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure>
+ getSenderKeyStatesList();
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure getSenderKeyStates(int index);
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ int getSenderKeyStatesCount();
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ java.util.List<? extends org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructureOrBuilder>
+ getSenderKeyStatesOrBuilderList();
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructureOrBuilder getSenderKeyStatesOrBuilder(
+ int index);
+ }
+ /**
+ * Protobuf type {@code textsecure.SenderKeyRecordStructure}
+ */
+ public static final class SenderKeyRecordStructure extends
+ com.google.protobuf.GeneratedMessage
+ implements SenderKeyRecordStructureOrBuilder {
+ // Use SenderKeyRecordStructure.newBuilder() to construct.
+ private SenderKeyRecordStructure(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private SenderKeyRecordStructure(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final SenderKeyRecordStructure defaultInstance;
+ public static SenderKeyRecordStructure getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public SenderKeyRecordStructure getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private SenderKeyRecordStructure(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 10: {
+ if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
+ senderKeyStates_ = new java.util.ArrayList<org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure>();
+ mutable_bitField0_ |= 0x00000001;
+ }
+ senderKeyStates_.add(input.readMessage(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.PARSER, extensionRegistry));
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
+ senderKeyStates_ = java.util.Collections.unmodifiableList(senderKeyStates_);
+ }
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyRecordStructure_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyRecordStructure_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure.class, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<SenderKeyRecordStructure> PARSER =
+ new com.google.protobuf.AbstractParser<SenderKeyRecordStructure>() {
+ public SenderKeyRecordStructure parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new SenderKeyRecordStructure(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<SenderKeyRecordStructure> getParserForType() {
+ return PARSER;
+ }
+
+ // repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;
+ public static final int SENDERKEYSTATES_FIELD_NUMBER = 1;
+ private java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure> senderKeyStates_;
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure> getSenderKeyStatesList() {
+ return senderKeyStates_;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public java.util.List<? extends org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructureOrBuilder>
+ getSenderKeyStatesOrBuilderList() {
+ return senderKeyStates_;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public int getSenderKeyStatesCount() {
+ return senderKeyStates_.size();
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure getSenderKeyStates(int index) {
+ return senderKeyStates_.get(index);
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructureOrBuilder getSenderKeyStatesOrBuilder(
+ int index) {
+ return senderKeyStates_.get(index);
+ }
+
+ private void initFields() {
+ senderKeyStates_ = java.util.Collections.emptyList();
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ for (int i = 0; i < senderKeyStates_.size(); i++) {
+ output.writeMessage(1, senderKeyStates_.get(i));
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ for (int i = 0; i < senderKeyStates_.size(); i++) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeMessageSize(1, senderKeyStates_.get(i));
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code textsecure.SenderKeyRecordStructure}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructureOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyRecordStructure_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyRecordStructure_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure.class, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure.Builder.class);
+ }
+
+ // Construct using org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ getSenderKeyStatesFieldBuilder();
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ if (senderKeyStatesBuilder_ == null) {
+ senderKeyStates_ = java.util.Collections.emptyList();
+ bitField0_ = (bitField0_ & ~0x00000001);
+ } else {
+ senderKeyStatesBuilder_.clear();
+ }
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.internal_static_textsecure_SenderKeyRecordStructure_descriptor;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure getDefaultInstanceForType() {
+ return org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure.getDefaultInstance();
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure build() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure buildPartial() {
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure result = new org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure(this);
+ int from_bitField0_ = bitField0_;
+ if (senderKeyStatesBuilder_ == null) {
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ senderKeyStates_ = java.util.Collections.unmodifiableList(senderKeyStates_);
+ bitField0_ = (bitField0_ & ~0x00000001);
+ }
+ result.senderKeyStates_ = senderKeyStates_;
+ } else {
+ result.senderKeyStates_ = senderKeyStatesBuilder_.build();
+ }
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure) {
+ return mergeFrom((org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure other) {
+ if (other == org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure.getDefaultInstance()) return this;
+ if (senderKeyStatesBuilder_ == null) {
+ if (!other.senderKeyStates_.isEmpty()) {
+ if (senderKeyStates_.isEmpty()) {
+ senderKeyStates_ = other.senderKeyStates_;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ } else {
+ ensureSenderKeyStatesIsMutable();
+ senderKeyStates_.addAll(other.senderKeyStates_);
+ }
+ onChanged();
+ }
+ } else {
+ if (!other.senderKeyStates_.isEmpty()) {
+ if (senderKeyStatesBuilder_.isEmpty()) {
+ senderKeyStatesBuilder_.dispose();
+ senderKeyStatesBuilder_ = null;
+ senderKeyStates_ = other.senderKeyStates_;
+ bitField0_ = (bitField0_ & ~0x00000001);
+ senderKeyStatesBuilder_ =
+ com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
+ getSenderKeyStatesFieldBuilder() : null;
+ } else {
+ senderKeyStatesBuilder_.addAllMessages(other.senderKeyStates_);
+ }
+ }
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyRecordStructure) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;
+ private java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure> senderKeyStates_ =
+ java.util.Collections.emptyList();
+ private void ensureSenderKeyStatesIsMutable() {
+ if (!((bitField0_ & 0x00000001) == 0x00000001)) {
+ senderKeyStates_ = new java.util.ArrayList<org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure>(senderKeyStates_);
+ bitField0_ |= 0x00000001;
+ }
+ }
+
+ private com.google.protobuf.RepeatedFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructureOrBuilder> senderKeyStatesBuilder_;
+
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure> getSenderKeyStatesList() {
+ if (senderKeyStatesBuilder_ == null) {
+ return java.util.Collections.unmodifiableList(senderKeyStates_);
+ } else {
+ return senderKeyStatesBuilder_.getMessageList();
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public int getSenderKeyStatesCount() {
+ if (senderKeyStatesBuilder_ == null) {
+ return senderKeyStates_.size();
+ } else {
+ return senderKeyStatesBuilder_.getCount();
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure getSenderKeyStates(int index) {
+ if (senderKeyStatesBuilder_ == null) {
+ return senderKeyStates_.get(index);
+ } else {
+ return senderKeyStatesBuilder_.getMessage(index);
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public Builder setSenderKeyStates(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure value) {
+ if (senderKeyStatesBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureSenderKeyStatesIsMutable();
+ senderKeyStates_.set(index, value);
+ onChanged();
+ } else {
+ senderKeyStatesBuilder_.setMessage(index, value);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public Builder setSenderKeyStates(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.Builder builderForValue) {
+ if (senderKeyStatesBuilder_ == null) {
+ ensureSenderKeyStatesIsMutable();
+ senderKeyStates_.set(index, builderForValue.build());
+ onChanged();
+ } else {
+ senderKeyStatesBuilder_.setMessage(index, builderForValue.build());
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public Builder addSenderKeyStates(org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure value) {
+ if (senderKeyStatesBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureSenderKeyStatesIsMutable();
+ senderKeyStates_.add(value);
+ onChanged();
+ } else {
+ senderKeyStatesBuilder_.addMessage(value);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public Builder addSenderKeyStates(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure value) {
+ if (senderKeyStatesBuilder_ == null) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ ensureSenderKeyStatesIsMutable();
+ senderKeyStates_.add(index, value);
+ onChanged();
+ } else {
+ senderKeyStatesBuilder_.addMessage(index, value);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public Builder addSenderKeyStates(
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.Builder builderForValue) {
+ if (senderKeyStatesBuilder_ == null) {
+ ensureSenderKeyStatesIsMutable();
+ senderKeyStates_.add(builderForValue.build());
+ onChanged();
+ } else {
+ senderKeyStatesBuilder_.addMessage(builderForValue.build());
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public Builder addSenderKeyStates(
+ int index, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.Builder builderForValue) {
+ if (senderKeyStatesBuilder_ == null) {
+ ensureSenderKeyStatesIsMutable();
+ senderKeyStates_.add(index, builderForValue.build());
+ onChanged();
+ } else {
+ senderKeyStatesBuilder_.addMessage(index, builderForValue.build());
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public Builder addAllSenderKeyStates(
+ java.lang.Iterable<? extends org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure> values) {
+ if (senderKeyStatesBuilder_ == null) {
+ ensureSenderKeyStatesIsMutable();
+ super.addAll(values, senderKeyStates_);
+ onChanged();
+ } else {
+ senderKeyStatesBuilder_.addAllMessages(values);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public Builder clearSenderKeyStates() {
+ if (senderKeyStatesBuilder_ == null) {
+ senderKeyStates_ = java.util.Collections.emptyList();
+ bitField0_ = (bitField0_ & ~0x00000001);
+ onChanged();
+ } else {
+ senderKeyStatesBuilder_.clear();
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public Builder removeSenderKeyStates(int index) {
+ if (senderKeyStatesBuilder_ == null) {
+ ensureSenderKeyStatesIsMutable();
+ senderKeyStates_.remove(index);
+ onChanged();
+ } else {
+ senderKeyStatesBuilder_.remove(index);
+ }
+ return this;
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.Builder getSenderKeyStatesBuilder(
+ int index) {
+ return getSenderKeyStatesFieldBuilder().getBuilder(index);
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructureOrBuilder getSenderKeyStatesOrBuilder(
+ int index) {
+ if (senderKeyStatesBuilder_ == null) {
+ return senderKeyStates_.get(index); } else {
+ return senderKeyStatesBuilder_.getMessageOrBuilder(index);
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public java.util.List<? extends org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructureOrBuilder>
+ getSenderKeyStatesOrBuilderList() {
+ if (senderKeyStatesBuilder_ != null) {
+ return senderKeyStatesBuilder_.getMessageOrBuilderList();
+ } else {
+ return java.util.Collections.unmodifiableList(senderKeyStates_);
+ }
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.Builder addSenderKeyStatesBuilder() {
+ return getSenderKeyStatesFieldBuilder().addBuilder(
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.getDefaultInstance());
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.Builder addSenderKeyStatesBuilder(
+ int index) {
+ return getSenderKeyStatesFieldBuilder().addBuilder(
+ index, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.getDefaultInstance());
+ }
+ /**
+ * <code>repeated .textsecure.SenderKeyStateStructure senderKeyStates = 1;</code>
+ */
+ public java.util.List<org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.Builder>
+ getSenderKeyStatesBuilderList() {
+ return getSenderKeyStatesFieldBuilder().getBuilderList();
+ }
+ private com.google.protobuf.RepeatedFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructureOrBuilder>
+ getSenderKeyStatesFieldBuilder() {
+ if (senderKeyStatesBuilder_ == null) {
+ senderKeyStatesBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
+ org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructure.Builder, org.whispersystems.libaxolotl.state.StorageProtos.SenderKeyStateStructureOrBuilder>(
+ senderKeyStates_,
+ ((bitField0_ & 0x00000001) == 0x00000001),
+ getParentForChildren(),
+ isClean());
+ senderKeyStates_ = null;
+ }
+ return senderKeyStatesBuilder_;
+ }
+
+ // @@protoc_insertion_point(builder_scope:textsecure.SenderKeyRecordStructure)
+ }
+
+ static {
+ defaultInstance = new SenderKeyRecordStructure(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:textsecure.SenderKeyRecordStructure)
+ }
+
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_SessionStructure_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_SessionStructure_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_SessionStructure_Chain_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_SessionStructure_Chain_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_SessionStructure_Chain_ChainKey_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_SessionStructure_Chain_ChainKey_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_SessionStructure_Chain_MessageKey_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_SessionStructure_Chain_MessageKey_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_SessionStructure_PendingKeyExchange_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_SessionStructure_PendingKeyExchange_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_SessionStructure_PendingPreKey_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_SessionStructure_PendingPreKey_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_RecordStructure_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_RecordStructure_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_PreKeyRecordStructure_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_PreKeyRecordStructure_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_SignedPreKeyRecordStructure_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_SignedPreKeyRecordStructure_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_IdentityKeyPairStructure_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_IdentityKeyPairStructure_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_SenderKeyStateStructure_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_SenderKeyStateStructure_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_SenderKeyStateStructure_SenderChainKey_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_SenderKeyStateStructure_SenderChainKey_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_SenderKeyStateStructure_SenderMessageKey_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_SenderKeyStateStructure_SenderMessageKey_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_SenderKeyStateStructure_SenderSigningKey_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_SenderKeyStateStructure_SenderSigningKey_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_textsecure_SenderKeyRecordStructure_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_textsecure_SenderKeyRecordStructure_fieldAccessorTable;
+
+ public static com.google.protobuf.Descriptors.FileDescriptor
+ getDescriptor() {
+ return descriptor;
+ }
+ private static com.google.protobuf.Descriptors.FileDescriptor
+ descriptor;
+ static {
+ java.lang.String[] descriptorData = {
+ "\n\032LocalStorageProtocol.proto\022\ntextsecure" +
+ "\"\323\010\n\020SessionStructure\022\026\n\016sessionVersion\030" +
+ "\001 \001(\r\022\033\n\023localIdentityPublic\030\002 \001(\014\022\034\n\024re" +
+ "moteIdentityPublic\030\003 \001(\014\022\017\n\007rootKey\030\004 \001(" +
+ "\014\022\027\n\017previousCounter\030\005 \001(\r\0227\n\013senderChai" +
+ "n\030\006 \001(\0132\".textsecure.SessionStructure.Ch" +
+ "ain\022:\n\016receiverChains\030\007 \003(\0132\".textsecure" +
+ ".SessionStructure.Chain\022K\n\022pendingKeyExc" +
+ "hange\030\010 \001(\0132/.textsecure.SessionStructur" +
+ "e.PendingKeyExchange\022A\n\rpendingPreKey\030\t ",
+ "\001(\0132*.textsecure.SessionStructure.Pendin" +
+ "gPreKey\022\034\n\024remoteRegistrationId\030\n \001(\r\022\033\n" +
+ "\023localRegistrationId\030\013 \001(\r\022\024\n\014needsRefre" +
+ "sh\030\014 \001(\010\022\024\n\014aliceBaseKey\030\r \001(\014\032\271\002\n\005Chain" +
+ "\022\030\n\020senderRatchetKey\030\001 \001(\014\022\037\n\027senderRatc" +
+ "hetKeyPrivate\030\002 \001(\014\022=\n\010chainKey\030\003 \001(\0132+." +
+ "textsecure.SessionStructure.Chain.ChainK" +
+ "ey\022B\n\013messageKeys\030\004 \003(\0132-.textsecure.Ses" +
+ "sionStructure.Chain.MessageKey\032&\n\010ChainK" +
+ "ey\022\r\n\005index\030\001 \001(\r\022\013\n\003key\030\002 \001(\014\032J\n\nMessag",
+ "eKey\022\r\n\005index\030\001 \001(\r\022\021\n\tcipherKey\030\002 \001(\014\022\016" +
+ "\n\006macKey\030\003 \001(\014\022\n\n\002iv\030\004 \001(\014\032\315\001\n\022PendingKe" +
+ "yExchange\022\020\n\010sequence\030\001 \001(\r\022\024\n\014localBase" +
+ "Key\030\002 \001(\014\022\033\n\023localBaseKeyPrivate\030\003 \001(\014\022\027" +
+ "\n\017localRatchetKey\030\004 \001(\014\022\036\n\026localRatchetK" +
+ "eyPrivate\030\005 \001(\014\022\030\n\020localIdentityKey\030\007 \001(" +
+ "\014\022\037\n\027localIdentityKeyPrivate\030\010 \001(\014\032J\n\rPe" +
+ "ndingPreKey\022\020\n\010preKeyId\030\001 \001(\r\022\026\n\016signedP" +
+ "reKeyId\030\003 \001(\005\022\017\n\007baseKey\030\002 \001(\014\"\177\n\017Record" +
+ "Structure\0224\n\016currentSession\030\001 \001(\0132\034.text",
+ "secure.SessionStructure\0226\n\020previousSessi" +
+ "ons\030\002 \003(\0132\034.textsecure.SessionStructure\"" +
+ "J\n\025PreKeyRecordStructure\022\n\n\002id\030\001 \001(\r\022\021\n\t" +
+ "publicKey\030\002 \001(\014\022\022\n\nprivateKey\030\003 \001(\014\"v\n\033S" +
+ "ignedPreKeyRecordStructure\022\n\n\002id\030\001 \001(\r\022\021" +
+ "\n\tpublicKey\030\002 \001(\014\022\022\n\nprivateKey\030\003 \001(\014\022\021\n" +
+ "\tsignature\030\004 \001(\014\022\021\n\ttimestamp\030\005 \001(\006\"A\n\030I" +
+ "dentityKeyPairStructure\022\021\n\tpublicKey\030\001 \001" +
+ "(\014\022\022\n\nprivateKey\030\002 \001(\014\"\270\003\n\027SenderKeyStat" +
+ "eStructure\022\023\n\013senderKeyId\030\001 \001(\r\022J\n\016sende",
+ "rChainKey\030\002 \001(\01322.textsecure.SenderKeySt" +
+ "ateStructure.SenderChainKey\022N\n\020senderSig" +
+ "ningKey\030\003 \001(\01324.textsecure.SenderKeyStat" +
+ "eStructure.SenderSigningKey\022O\n\021senderMes" +
+ "sageKeys\030\004 \003(\01324.textsecure.SenderKeySta" +
+ "teStructure.SenderMessageKey\0321\n\016SenderCh" +
+ "ainKey\022\021\n\titeration\030\001 \001(\r\022\014\n\004seed\030\002 \001(\014\032" +
+ "3\n\020SenderMessageKey\022\021\n\titeration\030\001 \001(\r\022\014" +
+ "\n\004seed\030\002 \001(\014\0323\n\020SenderSigningKey\022\016\n\006publ" +
+ "ic\030\001 \001(\014\022\017\n\007private\030\002 \001(\014\"X\n\030SenderKeyRe",
+ "cordStructure\022<\n\017senderKeyStates\030\001 \003(\0132#" +
+ ".textsecure.SenderKeyStateStructureB4\n#o" +
+ "rg.whispersystems.libaxolotl.stateB\rStor" +
+ "ageProtos"
+ };
+ com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
+ new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
+ public com.google.protobuf.ExtensionRegistry assignDescriptors(
+ com.google.protobuf.Descriptors.FileDescriptor root) {
+ descriptor = root;
+ internal_static_textsecure_SessionStructure_descriptor =
+ getDescriptor().getMessageTypes().get(0);
+ internal_static_textsecure_SessionStructure_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_SessionStructure_descriptor,
+ new java.lang.String[] { "SessionVersion", "LocalIdentityPublic", "RemoteIdentityPublic", "RootKey", "PreviousCounter", "SenderChain", "ReceiverChains", "PendingKeyExchange", "PendingPreKey", "RemoteRegistrationId", "LocalRegistrationId", "NeedsRefresh", "AliceBaseKey", });
+ internal_static_textsecure_SessionStructure_Chain_descriptor =
+ internal_static_textsecure_SessionStructure_descriptor.getNestedTypes().get(0);
+ internal_static_textsecure_SessionStructure_Chain_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_SessionStructure_Chain_descriptor,
+ new java.lang.String[] { "SenderRatchetKey", "SenderRatchetKeyPrivate", "ChainKey", "MessageKeys", });
+ internal_static_textsecure_SessionStructure_Chain_ChainKey_descriptor =
+ internal_static_textsecure_SessionStructure_Chain_descriptor.getNestedTypes().get(0);
+ internal_static_textsecure_SessionStructure_Chain_ChainKey_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_SessionStructure_Chain_ChainKey_descriptor,
+ new java.lang.String[] { "Index", "Key", });
+ internal_static_textsecure_SessionStructure_Chain_MessageKey_descriptor =
+ internal_static_textsecure_SessionStructure_Chain_descriptor.getNestedTypes().get(1);
+ internal_static_textsecure_SessionStructure_Chain_MessageKey_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_SessionStructure_Chain_MessageKey_descriptor,
+ new java.lang.String[] { "Index", "CipherKey", "MacKey", "Iv", });
+ internal_static_textsecure_SessionStructure_PendingKeyExchange_descriptor =
+ internal_static_textsecure_SessionStructure_descriptor.getNestedTypes().get(1);
+ internal_static_textsecure_SessionStructure_PendingKeyExchange_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_SessionStructure_PendingKeyExchange_descriptor,
+ new java.lang.String[] { "Sequence", "LocalBaseKey", "LocalBaseKeyPrivate", "LocalRatchetKey", "LocalRatchetKeyPrivate", "LocalIdentityKey", "LocalIdentityKeyPrivate", });
+ internal_static_textsecure_SessionStructure_PendingPreKey_descriptor =
+ internal_static_textsecure_SessionStructure_descriptor.getNestedTypes().get(2);
+ internal_static_textsecure_SessionStructure_PendingPreKey_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_SessionStructure_PendingPreKey_descriptor,
+ new java.lang.String[] { "PreKeyId", "SignedPreKeyId", "BaseKey", });
+ internal_static_textsecure_RecordStructure_descriptor =
+ getDescriptor().getMessageTypes().get(1);
+ internal_static_textsecure_RecordStructure_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_RecordStructure_descriptor,
+ new java.lang.String[] { "CurrentSession", "PreviousSessions", });
+ internal_static_textsecure_PreKeyRecordStructure_descriptor =
+ getDescriptor().getMessageTypes().get(2);
+ internal_static_textsecure_PreKeyRecordStructure_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_PreKeyRecordStructure_descriptor,
+ new java.lang.String[] { "Id", "PublicKey", "PrivateKey", });
+ internal_static_textsecure_SignedPreKeyRecordStructure_descriptor =
+ getDescriptor().getMessageTypes().get(3);
+ internal_static_textsecure_SignedPreKeyRecordStructure_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_SignedPreKeyRecordStructure_descriptor,
+ new java.lang.String[] { "Id", "PublicKey", "PrivateKey", "Signature", "Timestamp", });
+ internal_static_textsecure_IdentityKeyPairStructure_descriptor =
+ getDescriptor().getMessageTypes().get(4);
+ internal_static_textsecure_IdentityKeyPairStructure_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_IdentityKeyPairStructure_descriptor,
+ new java.lang.String[] { "PublicKey", "PrivateKey", });
+ internal_static_textsecure_SenderKeyStateStructure_descriptor =
+ getDescriptor().getMessageTypes().get(5);
+ internal_static_textsecure_SenderKeyStateStructure_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_SenderKeyStateStructure_descriptor,
+ new java.lang.String[] { "SenderKeyId", "SenderChainKey", "SenderSigningKey", "SenderMessageKeys", });
+ internal_static_textsecure_SenderKeyStateStructure_SenderChainKey_descriptor =
+ internal_static_textsecure_SenderKeyStateStructure_descriptor.getNestedTypes().get(0);
+ internal_static_textsecure_SenderKeyStateStructure_SenderChainKey_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_SenderKeyStateStructure_SenderChainKey_descriptor,
+ new java.lang.String[] { "Iteration", "Seed", });
+ internal_static_textsecure_SenderKeyStateStructure_SenderMessageKey_descriptor =
+ internal_static_textsecure_SenderKeyStateStructure_descriptor.getNestedTypes().get(1);
+ internal_static_textsecure_SenderKeyStateStructure_SenderMessageKey_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_SenderKeyStateStructure_SenderMessageKey_descriptor,
+ new java.lang.String[] { "Iteration", "Seed", });
+ internal_static_textsecure_SenderKeyStateStructure_SenderSigningKey_descriptor =
+ internal_static_textsecure_SenderKeyStateStructure_descriptor.getNestedTypes().get(2);
+ internal_static_textsecure_SenderKeyStateStructure_SenderSigningKey_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_SenderKeyStateStructure_SenderSigningKey_descriptor,
+ new java.lang.String[] { "Public", "Private", });
+ internal_static_textsecure_SenderKeyRecordStructure_descriptor =
+ getDescriptor().getMessageTypes().get(6);
+ internal_static_textsecure_SenderKeyRecordStructure_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_textsecure_SenderKeyRecordStructure_descriptor,
+ new java.lang.String[] { "SenderKeyStates", });
+ return null;
+ }
+ };
+ com.google.protobuf.Descriptors.FileDescriptor
+ .internalBuildGeneratedFileFrom(descriptorData,
+ new com.google.protobuf.Descriptors.FileDescriptor[] {
+ }, assigner);
+ }
+
+ // @@protoc_insertion_point(outer_class_scope)
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/util/ByteUtil.java b/src/main/java/org/whispersystems/libaxolotl/util/ByteUtil.java
new file mode 100644
index 00000000..c213ba0b
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/util/ByteUtil.java
@@ -0,0 +1,248 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl.util;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.text.ParseException;
+
+public class ByteUtil {
+
+ public static byte[] combine(byte[]... elements) {
+ try {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+
+ for (byte[] element : elements) {
+ baos.write(element);
+ }
+
+ return baos.toByteArray();
+ } catch (IOException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ public static byte[][] split(byte[] input, int firstLength, int secondLength) {
+ byte[][] parts = new byte[2][];
+
+ parts[0] = new byte[firstLength];
+ System.arraycopy(input, 0, parts[0], 0, firstLength);
+
+ parts[1] = new byte[secondLength];
+ System.arraycopy(input, firstLength, parts[1], 0, secondLength);
+
+ return parts;
+ }
+
+ public static byte[][] split(byte[] input, int firstLength, int secondLength, int thirdLength)
+ throws ParseException
+ {
+ if (input == null || firstLength < 0 || secondLength < 0 || thirdLength < 0 ||
+ input.length < firstLength + secondLength + thirdLength)
+ {
+ throw new ParseException("Input too small: " + (input == null ? null : Hex.toString(input)), 0);
+ }
+
+ byte[][] parts = new byte[3][];
+
+ parts[0] = new byte[firstLength];
+ System.arraycopy(input, 0, parts[0], 0, firstLength);
+
+ parts[1] = new byte[secondLength];
+ System.arraycopy(input, firstLength, parts[1], 0, secondLength);
+
+ parts[2] = new byte[thirdLength];
+ System.arraycopy(input, firstLength + secondLength, parts[2], 0, thirdLength);
+
+ return parts;
+ }
+
+ public static byte[] trim(byte[] input, int length) {
+ byte[] result = new byte[length];
+ System.arraycopy(input, 0, result, 0, result.length);
+
+ return result;
+ }
+
+ public static byte[] copyFrom(byte[] input) {
+ byte[] output = new byte[input.length];
+ System.arraycopy(input, 0, output, 0, output.length);
+
+ return output;
+ }
+
+ public static byte intsToByteHighAndLow(int highValue, int lowValue) {
+ return (byte)((highValue << 4 | lowValue) & 0xFF);
+ }
+
+ public static int highBitsToInt(byte value) {
+ return (value & 0xFF) >> 4;
+ }
+
+ public static int lowBitsToInt(byte value) {
+ return (value & 0xF);
+ }
+
+ public static int highBitsToMedium(int value) {
+ return (value >> 12);
+ }
+
+ public static int lowBitsToMedium(int value) {
+ return (value & 0xFFF);
+ }
+
+ public static byte[] shortToByteArray(int value) {
+ byte[] bytes = new byte[2];
+ shortToByteArray(bytes, 0, value);
+ return bytes;
+ }
+
+ public static int shortToByteArray(byte[] bytes, int offset, int value) {
+ bytes[offset+1] = (byte)value;
+ bytes[offset] = (byte)(value >> 8);
+ return 2;
+ }
+
+ public static int shortToLittleEndianByteArray(byte[] bytes, int offset, int value) {
+ bytes[offset] = (byte)value;
+ bytes[offset+1] = (byte)(value >> 8);
+ return 2;
+ }
+
+ public static byte[] mediumToByteArray(int value) {
+ byte[] bytes = new byte[3];
+ mediumToByteArray(bytes, 0, value);
+ return bytes;
+ }
+
+ public static int mediumToByteArray(byte[] bytes, int offset, int value) {
+ bytes[offset + 2] = (byte)value;
+ bytes[offset + 1] = (byte)(value >> 8);
+ bytes[offset] = (byte)(value >> 16);
+ return 3;
+ }
+
+ public static byte[] intToByteArray(int value) {
+ byte[] bytes = new byte[4];
+ intToByteArray(bytes, 0, value);
+ return bytes;
+ }
+
+ public static int intToByteArray(byte[] bytes, int offset, int value) {
+ bytes[offset + 3] = (byte)value;
+ bytes[offset + 2] = (byte)(value >> 8);
+ bytes[offset + 1] = (byte)(value >> 16);
+ bytes[offset] = (byte)(value >> 24);
+ return 4;
+ }
+
+ public static int intToLittleEndianByteArray(byte[] bytes, int offset, int value) {
+ bytes[offset] = (byte)value;
+ bytes[offset+1] = (byte)(value >> 8);
+ bytes[offset+2] = (byte)(value >> 16);
+ bytes[offset+3] = (byte)(value >> 24);
+ return 4;
+ }
+
+ public static byte[] longToByteArray(long l) {
+ byte[] bytes = new byte[8];
+ longToByteArray(bytes, 0, l);
+ return bytes;
+ }
+
+ public static int longToByteArray(byte[] bytes, int offset, long value) {
+ bytes[offset + 7] = (byte)value;
+ bytes[offset + 6] = (byte)(value >> 8);
+ bytes[offset + 5] = (byte)(value >> 16);
+ bytes[offset + 4] = (byte)(value >> 24);
+ bytes[offset + 3] = (byte)(value >> 32);
+ bytes[offset + 2] = (byte)(value >> 40);
+ bytes[offset + 1] = (byte)(value >> 48);
+ bytes[offset] = (byte)(value >> 56);
+ return 8;
+ }
+
+ public static int longTo4ByteArray(byte[] bytes, int offset, long value) {
+ bytes[offset + 3] = (byte)value;
+ bytes[offset + 2] = (byte)(value >> 8);
+ bytes[offset + 1] = (byte)(value >> 16);
+ bytes[offset + 0] = (byte)(value >> 24);
+ return 4;
+ }
+
+ public static int byteArrayToShort(byte[] bytes) {
+ return byteArrayToShort(bytes, 0);
+ }
+
+ public static int byteArrayToShort(byte[] bytes, int offset) {
+ return
+ (bytes[offset] & 0xff) << 8 | (bytes[offset + 1] & 0xff);
+ }
+
+ // The SSL patented 3-byte Value.
+ public static int byteArrayToMedium(byte[] bytes, int offset) {
+ return
+ (bytes[offset] & 0xff) << 16 |
+ (bytes[offset + 1] & 0xff) << 8 |
+ (bytes[offset + 2] & 0xff);
+ }
+
+ public static int byteArrayToInt(byte[] bytes) {
+ return byteArrayToInt(bytes, 0);
+ }
+
+ public static int byteArrayToInt(byte[] bytes, int offset) {
+ return
+ (bytes[offset] & 0xff) << 24 |
+ (bytes[offset + 1] & 0xff) << 16 |
+ (bytes[offset + 2] & 0xff) << 8 |
+ (bytes[offset + 3] & 0xff);
+ }
+
+ public static int byteArrayToIntLittleEndian(byte[] bytes, int offset) {
+ return
+ (bytes[offset + 3] & 0xff) << 24 |
+ (bytes[offset + 2] & 0xff) << 16 |
+ (bytes[offset + 1] & 0xff) << 8 |
+ (bytes[offset] & 0xff);
+ }
+
+ public static long byteArrayToLong(byte[] bytes) {
+ return byteArrayToLong(bytes, 0);
+ }
+
+ public static long byteArray4ToLong(byte[] bytes, int offset) {
+ return
+ ((bytes[offset + 0] & 0xffL) << 24) |
+ ((bytes[offset + 1] & 0xffL) << 16) |
+ ((bytes[offset + 2] & 0xffL) << 8) |
+ ((bytes[offset + 3] & 0xffL));
+ }
+
+ public static long byteArrayToLong(byte[] bytes, int offset) {
+ return
+ ((bytes[offset] & 0xffL) << 56) |
+ ((bytes[offset + 1] & 0xffL) << 48) |
+ ((bytes[offset + 2] & 0xffL) << 40) |
+ ((bytes[offset + 3] & 0xffL) << 32) |
+ ((bytes[offset + 4] & 0xffL) << 24) |
+ ((bytes[offset + 5] & 0xffL) << 16) |
+ ((bytes[offset + 6] & 0xffL) << 8) |
+ ((bytes[offset + 7] & 0xffL));
+ }
+
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/util/Hex.java b/src/main/java/org/whispersystems/libaxolotl/util/Hex.java
new file mode 100644
index 00000000..19285464
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/util/Hex.java
@@ -0,0 +1,77 @@
+/**
+ * Copyright (C) 2014 Open Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl.util;
+
+import java.io.IOException;
+
+/**
+ * Utility for generating hex dumps.
+ */
+public class Hex {
+
+ private final static char[] HEX_DIGITS = {
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
+ };
+
+ public static String toString(byte[] bytes) {
+ return toString(bytes, 0, bytes.length);
+ }
+
+ public static String toString(byte[] bytes, int offset, int length) {
+ StringBuffer buf = new StringBuffer();
+ for (int i = 0; i < length; i++) {
+ appendHexChar(buf, bytes[offset + i]);
+ buf.append(" ");
+ }
+ return buf.toString();
+ }
+
+ public static String toStringCondensed(byte[] bytes) {
+ StringBuffer buf = new StringBuffer();
+ for (int i=0;i<bytes.length;i++) {
+ appendHexChar(buf, bytes[i]);
+ }
+ return buf.toString();
+ }
+
+ public static byte[] fromStringCondensed(String encoded) throws IOException {
+ final char[] data = encoded.toCharArray();
+ final int len = data.length;
+
+ if ((len & 0x01) != 0) {
+ throw new IOException("Odd number of characters.");
+ }
+
+ final byte[] out = new byte[len >> 1];
+
+ for (int i = 0, j = 0; j < len; i++) {
+ int f = Character.digit(data[j], 16) << 4;
+ j++;
+ f = f | Character.digit(data[j], 16);
+ j++;
+ out[i] = (byte) (f & 0xFF);
+ }
+
+ return out;
+ }
+
+ private static void appendHexChar(StringBuffer buf, int b) {
+ buf.append(HEX_DIGITS[(b >> 4) & 0xf]);
+ buf.append(HEX_DIGITS[b & 0xf]);
+ }
+
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/util/KeyHelper.java b/src/main/java/org/whispersystems/libaxolotl/util/KeyHelper.java
new file mode 100644
index 00000000..96ee6563
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/util/KeyHelper.java
@@ -0,0 +1,143 @@
+package org.whispersystems.libaxolotl.util;
+
+import org.whispersystems.libaxolotl.IdentityKey;
+import org.whispersystems.libaxolotl.IdentityKeyPair;
+import org.whispersystems.libaxolotl.InvalidKeyException;
+import org.whispersystems.libaxolotl.ecc.Curve;
+import org.whispersystems.libaxolotl.ecc.ECKeyPair;
+import org.whispersystems.libaxolotl.state.PreKeyRecord;
+import org.whispersystems.libaxolotl.state.SignedPreKeyRecord;
+
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * Helper class for generating keys of different types.
+ *
+ * @author Moxie Marlinspike
+ */
+public class KeyHelper {
+
+ private KeyHelper() {}
+
+ /**
+ * Generate an identity key pair. Clients should only do this once,
+ * at install time.
+ *
+ * @return the generated IdentityKeyPair.
+ */
+ public static IdentityKeyPair generateIdentityKeyPair() {
+ ECKeyPair keyPair = Curve.generateKeyPair();
+ IdentityKey publicKey = new IdentityKey(keyPair.getPublicKey());
+ return new IdentityKeyPair(publicKey, keyPair.getPrivateKey());
+ }
+
+ /**
+ * Generate a registration ID. Clients should only do this once,
+ * at install time.
+ *
+ * @param extendedRange By default (false), the generated registration
+ * ID is sized to require the minimal possible protobuf
+ * encoding overhead. Specify true if the caller needs
+ * the full range of MAX_INT at the cost of slightly
+ * higher encoding overhead.
+ * @return the generated registration ID.
+ */
+ public static int generateRegistrationId(boolean extendedRange) {
+ try {
+ SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
+ if (extendedRange) return secureRandom.nextInt(Integer.MAX_VALUE - 1) + 1;
+ else return secureRandom.nextInt(16380) + 1;
+ } catch (NoSuchAlgorithmException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ public static int getRandomSequence(int max) {
+ try {
+ return SecureRandom.getInstance("SHA1PRNG").nextInt(max);
+ } catch (NoSuchAlgorithmException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ /**
+ * Generate a list of PreKeys. Clients should do this at install time, and
+ * subsequently any time the list of PreKeys stored on the server runs low.
+ * <p>
+ * PreKey IDs are shorts, so they will eventually be repeated. Clients should
+ * store PreKeys in a circular buffer, so that they are repeated as infrequently
+ * as possible.
+ *
+ * @param start The starting PreKey ID, inclusive.
+ * @param count The number of PreKeys to generate.
+ * @return the list of generated PreKeyRecords.
+ */
+ public static List<PreKeyRecord> generatePreKeys(int start, int count) {
+ List<PreKeyRecord> results = new LinkedList<>();
+
+ start--;
+
+ for (int i=0;i<count;i++) {
+ results.add(new PreKeyRecord(((start + i) % (Medium.MAX_VALUE-1)) + 1, Curve.generateKeyPair()));
+ }
+
+ return results;
+ }
+
+ /**
+ * Generate the last resort PreKey. Clients should do this only once, at install
+ * time, and durably store it for the length of the install.
+ *
+ * @return the generated last resort PreKeyRecord.
+ */
+ public static PreKeyRecord generateLastResortPreKey() {
+ ECKeyPair keyPair = Curve.generateKeyPair();
+ return new PreKeyRecord(Medium.MAX_VALUE, keyPair);
+ }
+
+ /**
+ * Generate a signed PreKey
+ *
+ * @param identityKeyPair The local client's identity key pair.
+ * @param signedPreKeyId The PreKey id to assign the generated signed PreKey
+ *
+ * @return the generated signed PreKey
+ * @throws InvalidKeyException when the provided identity key is invalid
+ */
+ public static SignedPreKeyRecord generateSignedPreKey(IdentityKeyPair identityKeyPair, int signedPreKeyId)
+ throws InvalidKeyException
+ {
+ ECKeyPair keyPair = Curve.generateKeyPair();
+ byte[] signature = Curve.calculateSignature(identityKeyPair.getPrivateKey(), keyPair.getPublicKey().serialize());
+
+ return new SignedPreKeyRecord(signedPreKeyId, System.currentTimeMillis(), keyPair, signature);
+ }
+
+
+ public static ECKeyPair generateSenderSigningKey() {
+ return Curve.generateKeyPair();
+ }
+
+ public static byte[] generateSenderKey() {
+ try {
+ byte[] key = new byte[32];
+ SecureRandom.getInstance("SHA1PRNG").nextBytes(key);
+
+ return key;
+ } catch (NoSuchAlgorithmException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ public static int generateSenderKeyId() {
+ try {
+ return SecureRandom.getInstance("SHA1PRNG").nextInt(Integer.MAX_VALUE);
+ } catch (NoSuchAlgorithmException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/util/Medium.java b/src/main/java/org/whispersystems/libaxolotl/util/Medium.java
new file mode 100644
index 00000000..d18b2d66
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/util/Medium.java
@@ -0,0 +1,5 @@
+package org.whispersystems.libaxolotl.util;
+
+public class Medium {
+ public static int MAX_VALUE = 0xFFFFFF;
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/util/Pair.java b/src/main/java/org/whispersystems/libaxolotl/util/Pair.java
new file mode 100644
index 00000000..0476d932
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/util/Pair.java
@@ -0,0 +1,51 @@
+/**
+ * Copyright (C) 2014 Open WhisperSystems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.whispersystems.libaxolotl.util;
+
+public class Pair<T1, T2> {
+ private final T1 v1;
+ private final T2 v2;
+
+ public Pair(T1 v1, T2 v2) {
+ this.v1 = v1;
+ this.v2 = v2;
+ }
+
+ public T1 first(){
+ return v1;
+ }
+
+ public T2 second(){
+ return v2;
+ }
+
+ public boolean equals(Object o) {
+ return o instanceof Pair &&
+ equal(((Pair) o).first(), first()) &&
+ equal(((Pair) o).second(), second());
+ }
+
+ public int hashCode() {
+ return first().hashCode() ^ second().hashCode();
+ }
+
+ private boolean equal(Object first, Object second) {
+ if (first == null && second == null) return true;
+ if (first == null || second == null) return false;
+ return first.equals(second);
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/util/guava/Absent.java b/src/main/java/org/whispersystems/libaxolotl/util/guava/Absent.java
new file mode 100644
index 00000000..bd06ded9
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/util/guava/Absent.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2011 The Guava Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.whispersystems.libaxolotl.util.guava;
+
+import static org.whispersystems.libaxolotl.util.guava.Preconditions.checkNotNull;
+
+
+
+import java.util.Collections;
+import java.util.Set;
+
+
+/**
+ * Implementation of an {@link Optional} not containing a reference.
+ */
+
+final class Absent extends Optional<Object> {
+ static final Absent INSTANCE = new Absent();
+
+ @Override public boolean isPresent() {
+ return false;
+ }
+
+ @Override public Object get() {
+ throw new IllegalStateException("value is absent");
+ }
+
+ @Override public Object or(Object defaultValue) {
+ return checkNotNull(defaultValue, "use orNull() instead of or(null)");
+ }
+
+ @SuppressWarnings("unchecked") // safe covariant cast
+ @Override public Optional<Object> or(Optional<?> secondChoice) {
+ return (Optional) checkNotNull(secondChoice);
+ }
+
+ @Override public Object or(Supplier<?> supplier) {
+ return checkNotNull(supplier.get(),
+ "use orNull() instead of a Supplier that returns null");
+ }
+
+ @Override public Object orNull() {
+ return null;
+ }
+
+ @Override public Set<Object> asSet() {
+ return Collections.emptySet();
+ }
+
+ @Override
+ public <V> Optional<V> transform(Function<? super Object, V> function) {
+ checkNotNull(function);
+ return Optional.absent();
+ }
+
+ @Override public boolean equals(Object object) {
+ return object == this;
+ }
+
+ @Override public int hashCode() {
+ return 0x598df91c;
+ }
+
+ @Override public String toString() {
+ return "Optional.absent()";
+ }
+
+ private Object readResolve() {
+ return INSTANCE;
+ }
+
+ private static final long serialVersionUID = 0;
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/util/guava/Function.java b/src/main/java/org/whispersystems/libaxolotl/util/guava/Function.java
new file mode 100644
index 00000000..1ad516c5
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/util/guava/Function.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2007 The Guava Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.whispersystems.libaxolotl.util.guava;
+
+
+
+/**
+ * Determines an output value based on an input value.
+ *
+ * <p>See the Guava User Guide article on <a href=
+ * "http://code.google.com/p/guava-libraries/wiki/FunctionalExplained">the use of {@code
+ * Function}</a>.
+ *
+ * @author Kevin Bourrillion
+ * @since 2.0 (imported from Google Collections Library)
+ */
+
+public interface Function<F, T> {
+ /**
+ * Returns the result of applying this function to {@code input}. This method is <i>generally
+ * expected</i>, but not absolutely required, to have the following properties:
+ *
+ * <ul>
+ * <li>Its execution does not cause any observable side effects.
+ * <li>The computation is <i>consistent with equals</i>; that is, {@link Objects#equal
+ * Objects.equal}{@code (a, b)} implies that {@code Objects.equal(function.apply(a),
+ * function.apply(b))}.
+ * </ul>
+ *
+ * @throws NullPointerException if {@code input} is null and this function does not accept null
+ * arguments
+ */
+ T apply(F input);
+
+ /**
+ * Indicates whether another object is equal to this function.
+ *
+ * <p>Most implementations will have no reason to override the behavior of {@link Object#equals}.
+ * However, an implementation may also choose to return {@code true} whenever {@code object} is a
+ * {@link Function} that it considers <i>interchangeable</i> with this one. "Interchangeable"
+ * <i>typically</i> means that {@code Objects.equal(this.apply(f), that.apply(f))} is true for all
+ * {@code f} of type {@code F}. Note that a {@code false} result from this method does not imply
+ * that the functions are known <i>not</i> to be interchangeable.
+ */
+ @Override
+ boolean equals(Object object);
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/util/guava/Optional.java b/src/main/java/org/whispersystems/libaxolotl/util/guava/Optional.java
new file mode 100644
index 00000000..4f2de832
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/util/guava/Optional.java
@@ -0,0 +1,232 @@
+/*
+ * Copyright (C) 2011 The Guava Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.whispersystems.libaxolotl.util.guava;
+
+import static org.whispersystems.libaxolotl.util.guava.Preconditions.checkNotNull;
+
+import java.io.Serializable;
+import java.util.Iterator;
+import java.util.Set;
+
+
+/**
+ * An immutable object that may contain a non-null reference to another object. Each
+ * instance of this type either contains a non-null reference, or contains nothing (in
+ * which case we say that the reference is "absent"); it is never said to "contain {@code
+ * null}".
+ *
+ * <p>A non-null {@code Optional<T>} reference can be used as a replacement for a nullable
+ * {@code T} reference. It allows you to represent "a {@code T} that must be present" and
+ * a "a {@code T} that might be absent" as two distinct types in your program, which can
+ * aid clarity.
+ *
+ * <p>Some uses of this class include
+ *
+ * <ul>
+ * <li>As a method return type, as an alternative to returning {@code null} to indicate
+ * that no value was available
+ * <li>To distinguish between "unknown" (for example, not present in a map) and "known to
+ * have no value" (present in the map, with value {@code Optional.absent()})
+ * <li>To wrap nullable references for storage in a collection that does not support
+ * {@code null} (though there are
+ * <a href="http://code.google.com/p/guava-libraries/wiki/LivingWithNullHostileCollections">
+ * several other approaches to this</a> that should be considered first)
+ * </ul>
+ *
+ * <p>A common alternative to using this class is to find or create a suitable
+ * <a href="http://en.wikipedia.org/wiki/Null_Object_pattern">null object</a> for the
+ * type in question.
+ *
+ * <p>This class is not intended as a direct analogue of any existing "option" or "maybe"
+ * construct from other programming environments, though it may bear some similarities.
+ *
+ * <p>See the Guava User Guide article on <a
+ * href="http://code.google.com/p/guava-libraries/wiki/UsingAndAvoidingNullExplained#Optional">
+ * using {@code Optional}</a>.
+ *
+ * @param <T> the type of instance that can be contained. {@code Optional} is naturally
+ * covariant on this type, so it is safe to cast an {@code Optional<T>} to {@code
+ * Optional<S>} for any supertype {@code S} of {@code T}.
+ * @author Kurt Alfred Kluever
+ * @author Kevin Bourrillion
+ * @since 10.0
+ */
+public abstract class Optional<T> implements Serializable {
+ /**
+ * Returns an {@code Optional} instance with no contained reference.
+ */
+ @SuppressWarnings("unchecked")
+ public static <T> Optional<T> absent() {
+ return (Optional<T>) Absent.INSTANCE;
+ }
+
+ /**
+ * Returns an {@code Optional} instance containing the given non-null reference.
+ */
+ public static <T> Optional<T> of(T reference) {
+ return new Present<T>(checkNotNull(reference));
+ }
+
+ /**
+ * If {@code nullableReference} is non-null, returns an {@code Optional} instance containing that
+ * reference; otherwise returns {@link Optional#absent}.
+ */
+ public static <T> Optional<T> fromNullable(T nullableReference) {
+ return (nullableReference == null)
+ ? Optional.<T>absent()
+ : new Present<T>(nullableReference);
+ }
+
+ Optional() {}
+
+ /**
+ * Returns {@code true} if this holder contains a (non-null) instance.
+ */
+ public abstract boolean isPresent();
+
+ /**
+ * Returns the contained instance, which must be present. If the instance might be
+ * absent, use {@link #or(Object)} or {@link #orNull} instead.
+ *
+ * @throws IllegalStateException if the instance is absent ({@link #isPresent} returns
+ * {@code false})
+ */
+ public abstract T get();
+
+ /**
+ * Returns the contained instance if it is present; {@code defaultValue} otherwise. If
+ * no default value should be required because the instance is known to be present, use
+ * {@link #get()} instead. For a default value of {@code null}, use {@link #orNull}.
+ *
+ * <p>Note about generics: The signature {@code public T or(T defaultValue)} is overly
+ * restrictive. However, the ideal signature, {@code public <S super T> S or(S)}, is not legal
+ * Java. As a result, some sensible operations involving subtypes are compile errors:
+ * <pre> {@code
+ *
+ * Optional<Integer> optionalInt = getSomeOptionalInt();
+ * Number value = optionalInt.or(0.5); // error
+ *
+ * FluentIterable<? extends Number> numbers = getSomeNumbers();
+ * Optional<? extends Number> first = numbers.first();
+ * Number value = first.or(0.5); // error}</pre>
+ *
+ * As a workaround, it is always safe to cast an {@code Optional<? extends T>} to {@code
+ * Optional<T>}. Casting either of the above example {@code Optional} instances to {@code
+ * Optional<Number>} (where {@code Number} is the desired output type) solves the problem:
+ * <pre> {@code
+ *
+ * Optional<Number> optionalInt = (Optional) getSomeOptionalInt();
+ * Number value = optionalInt.or(0.5); // fine
+ *
+ * FluentIterable<? extends Number> numbers = getSomeNumbers();
+ * Optional<Number> first = (Optional) numbers.first();
+ * Number value = first.or(0.5); // fine}</pre>
+ */
+ public abstract T or(T defaultValue);
+
+ /**
+ * Returns this {@code Optional} if it has a value present; {@code secondChoice}
+ * otherwise.
+ */
+ public abstract Optional<T> or(Optional<? extends T> secondChoice);
+
+ /**
+ * Returns the contained instance if it is present; {@code supplier.get()} otherwise. If the
+ * supplier returns {@code null}, a {@link NullPointerException} is thrown.
+ *
+ * @throws NullPointerException if the supplier returns {@code null}
+ */
+ public abstract T or(Supplier<? extends T> supplier);
+
+ /**
+ * Returns the contained instance if it is present; {@code null} otherwise. If the
+ * instance is known to be present, use {@link #get()} instead.
+ */
+ public abstract T orNull();
+
+ /**
+ * Returns an immutable singleton {@link Set} whose only element is the contained instance
+ * if it is present; an empty immutable {@link Set} otherwise.
+ *
+ * @since 11.0
+ */
+ public abstract Set<T> asSet();
+
+ /**
+ * If the instance is present, it is transformed with the given {@link Function}; otherwise,
+ * {@link Optional#absent} is returned. If the function returns {@code null}, a
+ * {@link NullPointerException} is thrown.
+ *
+ * @throws NullPointerException if the function returns {@code null}
+ *
+ * @since 12.0
+ */
+
+ public abstract <V> Optional<V> transform(Function<? super T, V> function);
+
+ /**
+ * Returns {@code true} if {@code object} is an {@code Optional} instance, and either
+ * the contained references are {@linkplain Object#equals equal} to each other or both
+ * are absent. Note that {@code Optional} instances of differing parameterized types can
+ * be equal.
+ */
+ @Override public abstract boolean equals(Object object);
+
+ /**
+ * Returns a hash code for this instance.
+ */
+ @Override public abstract int hashCode();
+
+ /**
+ * Returns a string representation for this instance. The form of this string
+ * representation is unspecified.
+ */
+ @Override public abstract String toString();
+
+ /**
+ * Returns the value of each present instance from the supplied {@code optionals}, in order,
+ * skipping over occurrences of {@link Optional#absent}. Iterators are unmodifiable and are
+ * evaluated lazily.
+ *
+ * @since 11.0 (generics widened in 13.0)
+ */
+
+// public static <T> Iterable<T> presentInstances(
+// final Iterable<? extends Optional<? extends T>> optionals) {
+// checkNotNull(optionals);
+// return new Iterable<T>() {
+// @Override public Iterator<T> iterator() {
+// return new AbstractIterator<T>() {
+// private final Iterator<? extends Optional<? extends T>> iterator =
+// checkNotNull(optionals.iterator());
+//
+// @Override protected T computeNext() {
+// while (iterator.hasNext()) {
+// Optional<? extends T> optional = iterator.next();
+// if (optional.isPresent()) {
+// return optional.get();
+// }
+// }
+// return endOfData();
+// }
+// };
+// };
+// };
+// }
+
+ private static final long serialVersionUID = 0;
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/util/guava/Preconditions.java b/src/main/java/org/whispersystems/libaxolotl/util/guava/Preconditions.java
new file mode 100644
index 00000000..ce253c65
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/util/guava/Preconditions.java
@@ -0,0 +1,447 @@
+/*
+ * Copyright (C) 2007 The Guava Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.whispersystems.libaxolotl.util.guava;
+
+
+import java.util.NoSuchElementException;
+
+
+
+/**
+ * Simple static methods to be called at the start of your own methods to verify
+ * correct arguments and state. This allows constructs such as
+ * <pre>
+ * if (count <= 0) {
+ * throw new IllegalArgumentException("must be positive: " + count);
+ * }</pre>
+ *
+ * to be replaced with the more compact
+ * <pre>
+ * checkArgument(count > 0, "must be positive: %s", count);</pre>
+ *
+ * Note that the sense of the expression is inverted; with {@code Preconditions}
+ * you declare what you expect to be <i>true</i>, just as you do with an
+ * <a href="http://java.sun.com/j2se/1.5.0/docs/guide/language/assert.html">
+ * {@code assert}</a> or a JUnit {@code assertTrue} call.
+ *
+ * <p><b>Warning:</b> only the {@code "%s"} specifier is recognized as a
+ * placeholder in these messages, not the full range of {@link
+ * String#format(String, Object[])} specifiers.
+ *
+ * <p>Take care not to confuse precondition checking with other similar types
+ * of checks! Precondition exceptions -- including those provided here, but also
+ * {@link IndexOutOfBoundsException}, {@link NoSuchElementException}, {@link
+ * UnsupportedOperationException} and others -- are used to signal that the
+ * <i>calling method</i> has made an error. This tells the caller that it should
+ * not have invoked the method when it did, with the arguments it did, or
+ * perhaps ever. Postcondition or other invariant failures should not throw
+ * these types of exceptions.
+ *
+ * <p>See the Guava User Guide on <a href=
+ * "http://code.google.com/p/guava-libraries/wiki/PreconditionsExplained">
+ * using {@code Preconditions}</a>.
+ *
+ * @author Kevin Bourrillion
+ * @since 2.0 (imported from Google Collections Library)
+ */
+
+public final class Preconditions {
+ private Preconditions() {}
+
+ /**
+ * Ensures the truth of an expression involving one or more parameters to the
+ * calling method.
+ *
+ * @param expression a boolean expression
+ * @throws IllegalArgumentException if {@code expression} is false
+ */
+ public static void checkArgument(boolean expression) {
+ if (!expression) {
+ throw new IllegalArgumentException();
+ }
+ }
+
+ /**
+ * Ensures the truth of an expression involving one or more parameters to the
+ * calling method.
+ *
+ * @param expression a boolean expression
+ * @param errorMessage the exception message to use if the check fails; will
+ * be converted to a string using {@link String#valueOf(Object)}
+ * @throws IllegalArgumentException if {@code expression} is false
+ */
+ public static void checkArgument(
+ boolean expression, Object errorMessage) {
+ if (!expression) {
+ throw new IllegalArgumentException(String.valueOf(errorMessage));
+ }
+ }
+
+ /**
+ * Ensures the truth of an expression involving one or more parameters to the
+ * calling method.
+ *
+ * @param expression a boolean expression
+ * @param errorMessageTemplate a template for the exception message should the
+ * check fail. The message is formed by replacing each {@code %s}
+ * placeholder in the template with an argument. These are matched by
+ * position - the first {@code %s} gets {@code errorMessageArgs[0]}, etc.
+ * Unmatched arguments will be appended to the formatted message in square
+ * braces. Unmatched placeholders will be left as-is.
+ * @param errorMessageArgs the arguments to be substituted into the message
+ * template. Arguments are converted to strings using
+ * {@link String#valueOf(Object)}.
+ * @throws IllegalArgumentException if {@code expression} is false
+ * @throws NullPointerException if the check fails and either {@code
+ * errorMessageTemplate} or {@code errorMessageArgs} is null (don't let
+ * this happen)
+ */
+ public static void checkArgument(boolean expression,
+ String errorMessageTemplate,
+ Object... errorMessageArgs) {
+ if (!expression) {
+ throw new IllegalArgumentException(
+ format(errorMessageTemplate, errorMessageArgs));
+ }
+ }
+
+ /**
+ * Ensures the truth of an expression involving the state of the calling
+ * instance, but not involving any parameters to the calling method.
+ *
+ * @param expression a boolean expression
+ * @throws IllegalStateException if {@code expression} is false
+ */
+ public static void checkState(boolean expression) {
+ if (!expression) {
+ throw new IllegalStateException();
+ }
+ }
+
+ /**
+ * Ensures the truth of an expression involving the state of the calling
+ * instance, but not involving any parameters to the calling method.
+ *
+ * @param expression a boolean expression
+ * @param errorMessage the exception message to use if the check fails; will
+ * be converted to a string using {@link String#valueOf(Object)}
+ * @throws IllegalStateException if {@code expression} is false
+ */
+ public static void checkState(
+ boolean expression, Object errorMessage) {
+ if (!expression) {
+ throw new IllegalStateException(String.valueOf(errorMessage));
+ }
+ }
+
+ /**
+ * Ensures the truth of an expression involving the state of the calling
+ * instance, but not involving any parameters to the calling method.
+ *
+ * @param expression a boolean expression
+ * @param errorMessageTemplate a template for the exception message should the
+ * check fail. The message is formed by replacing each {@code %s}
+ * placeholder in the template with an argument. These are matched by
+ * position - the first {@code %s} gets {@code errorMessageArgs[0]}, etc.
+ * Unmatched arguments will be appended to the formatted message in square
+ * braces. Unmatched placeholders will be left as-is.
+ * @param errorMessageArgs the arguments to be substituted into the message
+ * template. Arguments are converted to strings using
+ * {@link String#valueOf(Object)}.
+ * @throws IllegalStateException if {@code expression} is false
+ * @throws NullPointerException if the check fails and either {@code
+ * errorMessageTemplate} or {@code errorMessageArgs} is null (don't let
+ * this happen)
+ */
+ public static void checkState(boolean expression,
+ String errorMessageTemplate,
+ Object... errorMessageArgs) {
+ if (!expression) {
+ throw new IllegalStateException(
+ format(errorMessageTemplate, errorMessageArgs));
+ }
+ }
+
+ /**
+ * Ensures that an object reference passed as a parameter to the calling
+ * method is not null.
+ *
+ * @param reference an object reference
+ * @return the non-null reference that was validated
+ * @throws NullPointerException if {@code reference} is null
+ */
+ public static <T> T checkNotNull(T reference) {
+ if (reference == null) {
+ throw new NullPointerException();
+ }
+ return reference;
+ }
+
+ /**
+ * Ensures that an object reference passed as a parameter to the calling
+ * method is not null.
+ *
+ * @param reference an object reference
+ * @param errorMessage the exception message to use if the check fails; will
+ * be converted to a string using {@link String#valueOf(Object)}
+ * @return the non-null reference that was validated
+ * @throws NullPointerException if {@code reference} is null
+ */
+ public static <T> T checkNotNull(T reference, Object errorMessage) {
+ if (reference == null) {
+ throw new NullPointerException(String.valueOf(errorMessage));
+ }
+ return reference;
+ }
+
+ /**
+ * Ensures that an object reference passed as a parameter to the calling
+ * method is not null.
+ *
+ * @param reference an object reference
+ * @param errorMessageTemplate a template for the exception message should the
+ * check fail. The message is formed by replacing each {@code %s}
+ * placeholder in the template with an argument. These are matched by
+ * position - the first {@code %s} gets {@code errorMessageArgs[0]}, etc.
+ * Unmatched arguments will be appended to the formatted message in square
+ * braces. Unmatched placeholders will be left as-is.
+ * @param errorMessageArgs the arguments to be substituted into the message
+ * template. Arguments are converted to strings using
+ * {@link String#valueOf(Object)}.
+ * @return the non-null reference that was validated
+ * @throws NullPointerException if {@code reference} is null
+ */
+ public static <T> T checkNotNull(T reference,
+ String errorMessageTemplate,
+ Object... errorMessageArgs) {
+ if (reference == null) {
+ // If either of these parameters is null, the right thing happens anyway
+ throw new NullPointerException(
+ format(errorMessageTemplate, errorMessageArgs));
+ }
+ return reference;
+ }
+
+ /*
+ * All recent hotspots (as of 2009) *really* like to have the natural code
+ *
+ * if (guardExpression) {
+ * throw new BadException(messageExpression);
+ * }
+ *
+ * refactored so that messageExpression is moved to a separate
+ * String-returning method.
+ *
+ * if (guardExpression) {
+ * throw new BadException(badMsg(...));
+ * }
+ *
+ * The alternative natural refactorings into void or Exception-returning
+ * methods are much slower. This is a big deal - we're talking factors of
+ * 2-8 in microbenchmarks, not just 10-20%. (This is a hotspot optimizer
+ * bug, which should be fixed, but that's a separate, big project).
+ *
+ * The coding pattern above is heavily used in java.util, e.g. in ArrayList.
+ * There is a RangeCheckMicroBenchmark in the JDK that was used to test this.
+ *
+ * But the methods in this class want to throw different exceptions,
+ * depending on the args, so it appears that this pattern is not directly
+ * applicable. But we can use the ridiculous, devious trick of throwing an
+ * exception in the middle of the construction of another exception.
+ * Hotspot is fine with that.
+ */
+
+ /**
+ * Ensures that {@code index} specifies a valid <i>element</i> in an array,
+ * list or string of size {@code size}. An element index may range from zero,
+ * inclusive, to {@code size}, exclusive.
+ *
+ * @param index a user-supplied index identifying an element of an array, list
+ * or string
+ * @param size the size of that array, list or string
+ * @return the value of {@code index}
+ * @throws IndexOutOfBoundsException if {@code index} is negative or is not
+ * less than {@code size}
+ * @throws IllegalArgumentException if {@code size} is negative
+ */
+ public static int checkElementIndex(int index, int size) {
+ return checkElementIndex(index, size, "index");
+ }
+
+ /**
+ * Ensures that {@code index} specifies a valid <i>element</i> in an array,
+ * list or string of size {@code size}. An element index may range from zero,
+ * inclusive, to {@code size}, exclusive.
+ *
+ * @param index a user-supplied index identifying an element of an array, list
+ * or string
+ * @param size the size of that array, list or string
+ * @param desc the text to use to describe this index in an error message
+ * @return the value of {@code index}
+ * @throws IndexOutOfBoundsException if {@code index} is negative or is not
+ * less than {@code size}
+ * @throws IllegalArgumentException if {@code size} is negative
+ */
+ public static int checkElementIndex(
+ int index, int size, String desc) {
+ // Carefully optimized for execution by hotspot (explanatory comment above)
+ if (index < 0 || index >= size) {
+ throw new IndexOutOfBoundsException(badElementIndex(index, size, desc));
+ }
+ return index;
+ }
+
+ private static String badElementIndex(int index, int size, String desc) {
+ if (index < 0) {
+ return format("%s (%s) must not be negative", desc, index);
+ } else if (size < 0) {
+ throw new IllegalArgumentException("negative size: " + size);
+ } else { // index >= size
+ return format("%s (%s) must be less than size (%s)", desc, index, size);
+ }
+ }
+
+ /**
+ * Ensures that {@code index} specifies a valid <i>position</i> in an array,
+ * list or string of size {@code size}. A position index may range from zero
+ * to {@code size}, inclusive.
+ *
+ * @param index a user-supplied index identifying a position in an array, list
+ * or string
+ * @param size the size of that array, list or string
+ * @return the value of {@code index}
+ * @throws IndexOutOfBoundsException if {@code index} is negative or is
+ * greater than {@code size}
+ * @throws IllegalArgumentException if {@code size} is negative
+ */
+ public static int checkPositionIndex(int index, int size) {
+ return checkPositionIndex(index, size, "index");
+ }
+
+ /**
+ * Ensures that {@code index} specifies a valid <i>position</i> in an array,
+ * list or string of size {@code size}. A position index may range from zero
+ * to {@code size}, inclusive.
+ *
+ * @param index a user-supplied index identifying a position in an array, list
+ * or string
+ * @param size the size of that array, list or string
+ * @param desc the text to use to describe this index in an error message
+ * @return the value of {@code index}
+ * @throws IndexOutOfBoundsException if {@code index} is negative or is
+ * greater than {@code size}
+ * @throws IllegalArgumentException if {@code size} is negative
+ */
+ public static int checkPositionIndex(
+ int index, int size, String desc) {
+ // Carefully optimized for execution by hotspot (explanatory comment above)
+ if (index < 0 || index > size) {
+ throw new IndexOutOfBoundsException(badPositionIndex(index, size, desc));
+ }
+ return index;
+ }
+
+ private static String badPositionIndex(int index, int size, String desc) {
+ if (index < 0) {
+ return format("%s (%s) must not be negative", desc, index);
+ } else if (size < 0) {
+ throw new IllegalArgumentException("negative size: " + size);
+ } else { // index > size
+ return format("%s (%s) must not be greater than size (%s)",
+ desc, index, size);
+ }
+ }
+
+ /**
+ * Ensures that {@code start} and {@code end} specify a valid <i>positions</i>
+ * in an array, list or string of size {@code size}, and are in order. A
+ * position index may range from zero to {@code size}, inclusive.
+ *
+ * @param start a user-supplied index identifying a starting position in an
+ * array, list or string
+ * @param end a user-supplied index identifying a ending position in an array,
+ * list or string
+ * @param size the size of that array, list or string
+ * @throws IndexOutOfBoundsException if either index is negative or is
+ * greater than {@code size}, or if {@code end} is less than {@code start}
+ * @throws IllegalArgumentException if {@code size} is negative
+ */
+ public static void checkPositionIndexes(int start, int end, int size) {
+ // Carefully optimized for execution by hotspot (explanatory comment above)
+ if (start < 0 || end < start || end > size) {
+ throw new IndexOutOfBoundsException(badPositionIndexes(start, end, size));
+ }
+ }
+
+ private static String badPositionIndexes(int start, int end, int size) {
+ if (start < 0 || start > size) {
+ return badPositionIndex(start, size, "start index");
+ }
+ if (end < 0 || end > size) {
+ return badPositionIndex(end, size, "end index");
+ }
+ // end < start
+ return format("end index (%s) must not be less than start index (%s)",
+ end, start);
+ }
+
+ /**
+ * Substitutes each {@code %s} in {@code template} with an argument. These
+ * are matched by position - the first {@code %s} gets {@code args[0]}, etc.
+ * If there are more arguments than placeholders, the unmatched arguments will
+ * be appended to the end of the formatted message in square braces.
+ *
+ * @param template a non-null string containing 0 or more {@code %s}
+ * placeholders.
+ * @param args the arguments to be substituted into the message
+ * template. Arguments are converted to strings using
+ * {@link String#valueOf(Object)}. Arguments can be null.
+ */
+ static String format(String template,
+ Object... args) {
+ template = String.valueOf(template); // null -> "null"
+
+ // start substituting the arguments into the '%s' placeholders
+ StringBuilder builder = new StringBuilder(
+ template.length() + 16 * args.length);
+ int templateStart = 0;
+ int i = 0;
+ while (i < args.length) {
+ int placeholderStart = template.indexOf("%s", templateStart);
+ if (placeholderStart == -1) {
+ break;
+ }
+ builder.append(template.substring(templateStart, placeholderStart));
+ builder.append(args[i++]);
+ templateStart = placeholderStart + 2;
+ }
+ builder.append(template.substring(templateStart));
+
+ // if we run out of placeholders, append the extra args in square braces
+ if (i < args.length) {
+ builder.append(" [");
+ builder.append(args[i++]);
+ while (i < args.length) {
+ builder.append(", ");
+ builder.append(args[i++]);
+ }
+ builder.append(']');
+ }
+
+ return builder.toString();
+ }
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/util/guava/Present.java b/src/main/java/org/whispersystems/libaxolotl/util/guava/Present.java
new file mode 100644
index 00000000..630570ff
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/util/guava/Present.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2011 The Guava Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.whispersystems.libaxolotl.util.guava;
+
+import static org.whispersystems.libaxolotl.util.guava.Preconditions.checkNotNull;
+
+import java.util.Collections;
+import java.util.Set;
+
+/**
+ * Implementation of an {@link Optional} containing a reference.
+ */
+
+final class Present<T> extends Optional<T> {
+ private final T reference;
+
+ Present(T reference) {
+ this.reference = reference;
+ }
+
+ @Override public boolean isPresent() {
+ return true;
+ }
+
+ @Override public T get() {
+ return reference;
+ }
+
+ @Override public T or(T defaultValue) {
+ checkNotNull(defaultValue, "use orNull() instead of or(null)");
+ return reference;
+ }
+
+ @Override public Optional<T> or(Optional<? extends T> secondChoice) {
+ checkNotNull(secondChoice);
+ return this;
+ }
+
+ @Override public T or(Supplier<? extends T> supplier) {
+ checkNotNull(supplier);
+ return reference;
+ }
+
+ @Override public T orNull() {
+ return reference;
+ }
+
+ @Override public Set<T> asSet() {
+ return Collections.singleton(reference);
+ }
+
+ @Override public <V> Optional<V> transform(Function<? super T, V> function) {
+ return new Present<V>(checkNotNull(function.apply(reference),
+ "Transformation function cannot return null."));
+ }
+
+ @Override public boolean equals(Object object) {
+ if (object instanceof Present) {
+ Present<?> other = (Present<?>) object;
+ return reference.equals(other.reference);
+ }
+ return false;
+ }
+
+ @Override public int hashCode() {
+ return 0x598df91c + reference.hashCode();
+ }
+
+ @Override public String toString() {
+ return "Optional.of(" + reference + ")";
+ }
+
+ private static final long serialVersionUID = 0;
+}
diff --git a/src/main/java/org/whispersystems/libaxolotl/util/guava/Supplier.java b/src/main/java/org/whispersystems/libaxolotl/util/guava/Supplier.java
new file mode 100644
index 00000000..ba880707
--- /dev/null
+++ b/src/main/java/org/whispersystems/libaxolotl/util/guava/Supplier.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2007 The Guava Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.whispersystems.libaxolotl.util.guava;
+
+
+/**
+ * A class that can supply objects of a single type. Semantically, this could
+ * be a factory, generator, builder, closure, or something else entirely. No
+ * guarantees are implied by this interface.
+ *
+ * @author Harry Heymann
+ * @since 2.0 (imported from Google Collections Library)
+ */
+public interface Supplier<T> {
+ /**
+ * Retrieves an instance of the appropriate type. The returned object may or
+ * may not be a new instance, depending on the implementation.
+ *
+ * @return an instance of the appropriate type
+ */
+ T get();
+}