PeterCxy/open-keychain
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases 1 Wiki Activity

force reinserting keys on manual key update

Browse source
This commit is contained in:
Vincent Breitmoser 2018-07-14 13:18:08 +02:00
parent e3e5f7feec
commit 634694b20e
3 changed files with 31 additions and 25 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

26
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/ImportOperation.java
View file

@ -110,20 +110,20 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
// Overloaded functions for using progressable supplied in constructor during import // Overloaded functions for using progressable supplied in constructor during import
public ImportKeyResult serialKeyRingImport(Iterator<ParcelableKeyRing> entries, int num, public ImportKeyResult serialKeyRingImport(Iterator<ParcelableKeyRing> entries, int num,
HkpKeyserverAddress keyserver, ParcelableProxy proxy, boolean skipSave) { HkpKeyserverAddress keyserver, ParcelableProxy proxy, boolean skipSave, boolean forceReinsert) {
return serialKeyRingImport(entries, num, keyserver, mProgressable, proxy, skipSave); return serialKeyRingImport(entries, num, keyserver, mProgressable, proxy, skipSave, forceReinsert);
} }
@NonNull @NonNull
private ImportKeyResult serialKeyRingImport(ParcelableFileCache<ParcelableKeyRing> cache, private ImportKeyResult serialKeyRingImport(ParcelableFileCache<ParcelableKeyRing> cache,
HkpKeyserverAddress keyserver, ParcelableProxy proxy, boolean skipSave) { HkpKeyserverAddress keyserver, ParcelableProxy proxy, boolean skipSave, boolean forceReinsert) {
// get entries from cached file // get entries from cached file
try { try {
IteratorWithSize<ParcelableKeyRing> it = cache.readCache(); IteratorWithSize<ParcelableKeyRing> it = cache.readCache();
int numEntries = it.getSize(); int numEntries = it.getSize();
return serialKeyRingImport(it, numEntries, keyserver, mProgressable, proxy, skipSave); return serialKeyRingImport(it, numEntries, keyserver, mProgressable, proxy, skipSave, forceReinsert);
} catch (IOException e) { } catch (IOException e) {
// Special treatment here, we need a lot // Special treatment here, we need a lot
@ -148,8 +148,8 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
*/ */
@NonNull @NonNull
private ImportKeyResult serialKeyRingImport(Iterator<ParcelableKeyRing> entries, int numTotalKeys, private ImportKeyResult serialKeyRingImport(Iterator<ParcelableKeyRing> entries, int numTotalKeys,
HkpKeyserverAddress hkpKeyserver, Progressable progressable, HkpKeyserverAddress hkpKeyserver, Progressable progressable, @NonNull ParcelableProxy proxy,
@NonNull ParcelableProxy proxy, boolean skipSave) { boolean skipSave, boolean forceReinsert) {
if (progressable != null) { if (progressable != null) {
progressable.setProgress(R.string.progress_importing, 0, 100); progressable.setProgress(R.string.progress_importing, 0, 100);
} }
@ -232,7 +232,7 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
result = mKeyWritableRepository.saveSecretKeyRing(key, canKeyRings, skipSave); result = mKeyWritableRepository.saveSecretKeyRing(key, canKeyRings, skipSave);
} else { } else {
result = mKeyWritableRepository.savePublicKeyRing(key, entry.getExpectedFingerprint(), canKeyRings, result = mKeyWritableRepository.savePublicKeyRing(key, entry.getExpectedFingerprint(), canKeyRings,
false, skipSave); forceReinsert, skipSave);
} }
} }
if (!result.success()) { if (!result.success()) {
@ -490,12 +490,13 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
List<ParcelableKeyRing> keyList = importInput.getKeyList(); List<ParcelableKeyRing> keyList = importInput.getKeyList();
HkpKeyserverAddress keyServer = importInput.getKeyserver(); HkpKeyserverAddress keyServer = importInput.getKeyserver();
boolean skipSave = importInput.isSkipSave(); boolean skipSave = importInput.isSkipSave();
boolean forceReinsert = importInput.isForceReinsert();
ImportKeyResult result; ImportKeyResult result;
if (keyList == null) {// import from file, do serially if (keyList == null) {// import from file, do serially
ParcelableFileCache<ParcelableKeyRing> cache = ParcelableFileCache<ParcelableKeyRing> cache =
new ParcelableFileCache<>(mContext, CACHE_FILE_NAME); new ParcelableFileCache<>(mContext, CACHE_FILE_NAME);
result = serialKeyRingImport(cache, null, null, skipSave); result = serialKeyRingImport(cache, null, null, skipSave, forceReinsert);
} else { } else {
ParcelableProxy proxy; ParcelableProxy proxy;
if (cryptoInput.getParcelableProxy() == null) { if (cryptoInput.getParcelableProxy() == null) {
@ -510,7 +511,7 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
proxy = cryptoInput.getParcelableProxy(); proxy = cryptoInput.getParcelableProxy();
} }
result = multiThreadedKeyImport(keyList, keyServer, proxy, skipSave); result = multiThreadedKeyImport(keyList, keyServer, proxy, skipSave, forceReinsert);
} }
if (!skipSave) { if (!skipSave) {
@ -520,9 +521,8 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
} }
@NonNull @NonNull
private ImportKeyResult multiThreadedKeyImport(List<ParcelableKeyRing> keyList, private ImportKeyResult multiThreadedKeyImport(List<ParcelableKeyRing> keyList, HkpKeyserverAddress keyServer,
final HkpKeyserverAddress keyServer, final ParcelableProxy proxy, ParcelableProxy proxy, boolean skipSave, boolean forceReinsert) {
final boolean skipSave) {
Timber.d("Multi-threaded key import starting"); Timber.d("Multi-threaded key import starting");
final Iterator<ParcelableKeyRing> keyListIterator = keyList.iterator(); final Iterator<ParcelableKeyRing> keyListIterator = keyList.iterator();
@ -551,7 +551,7 @@ public class ImportOperation extends BaseReadWriteOperation<ImportKeyringParcel>
ProgressScaler ignoreProgressable = new ProgressScaler(); ProgressScaler ignoreProgressable = new ProgressScaler();
return serialKeyRingImport(list.iterator(), 1, keyServer, ignoreProgressable, return serialKeyRingImport(list.iterator(), 1, keyServer, ignoreProgressable,
proxy, skipSave); proxy, skipSave, forceReinsert);
} }
}; };

12
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/KeySyncOperation.java
View file

@ -57,13 +57,13 @@ public class KeySyncOperation extends BaseReadWriteOperation<KeySyncParcel> {
// no explicit proxy, retrieve from preferences. Check if we should do a staggered sync // no explicit proxy, retrieve from preferences. Check if we should do a staggered sync
CryptoInputParcel cryptoInputParcel = CryptoInputParcel.createCryptoInputParcel(); CryptoInputParcel cryptoInputParcel = CryptoInputParcel.createCryptoInputParcel();
boolean reinsertAll = input.getRefreshAll();
ImportKeyResult importKeyResult; ImportKeyResult importKeyResult;
if (preferences.getParcelableProxy().isTorEnabled()) { if (!reinsertAll && preferences.getParcelableProxy().isTorEnabled()) {
importKeyResult = staggeredUpdate(staleKeyParcelableKeyRings, cryptoInputParcel); importKeyResult = staggeredUpdate(staleKeyParcelableKeyRings, cryptoInputParcel);
} else { } else {
importKeyResult = importKeyResult = directUpdate(staleKeyParcelableKeyRings, cryptoInputParcel, reinsertAll);
directUpdate(staleKeyParcelableKeyRings, cryptoInputParcel);
} }
return importKeyResult; return importKeyResult;
} }
@ -77,12 +77,12 @@ public class KeySyncOperation extends BaseReadWriteOperation<KeySyncParcel> {
return result; return result;
} }
private ImportKeyResult directUpdate(List<ParcelableKeyRing> keyList, private ImportKeyResult directUpdate(List<ParcelableKeyRing> keyList, CryptoInputParcel cryptoInputParcel,
CryptoInputParcel cryptoInputParcel) { boolean reinsertAll) {
Timber.d("Starting normal update"); Timber.d("Starting normal update");
ImportOperation importOp = new ImportOperation(mContext, mKeyWritableRepository, mProgressable, mCancelled); ImportOperation importOp = new ImportOperation(mContext, mKeyWritableRepository, mProgressable, mCancelled);
return importOp.execute( return importOp.execute(
ImportKeyringParcel.createImportKeyringParcel(keyList, preferences.getPreferredKeyserver()), ImportKeyringParcel.createImportKeyringParcel(keyList, preferences.getPreferredKeyserver(), reinsertAll),
cryptoInputParcel cryptoInputParcel
); );
} }

18
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/ImportKeyringParcel.java
View file

@ -35,31 +35,37 @@ public abstract class ImportKeyringParcel implements Parcelable {
@Nullable // must be set if keys are to be imported from a keyserver @Nullable // must be set if keys are to be imported from a keyserver
public abstract HkpKeyserverAddress getKeyserver(); public abstract HkpKeyserverAddress getKeyserver();
public abstract boolean isSkipSave(); public abstract boolean isSkipSave();
public abstract boolean isForceReinsert();
public static ImportKeyringParcel createImportKeyringParcel(List<ParcelableKeyRing> keyList, public static ImportKeyringParcel createImportKeyringParcel(List<ParcelableKeyRing> keyList,
HkpKeyserverAddress keyserver) { HkpKeyserverAddress keyserver) {
return new AutoValue_ImportKeyringParcel(keyList, keyserver, false); return new AutoValue_ImportKeyringParcel(keyList, keyserver, false, false);
}
public static ImportKeyringParcel createImportKeyringParcel(List<ParcelableKeyRing> keyList,
HkpKeyserverAddress keyserver, boolean forceReinsert) {
return new AutoValue_ImportKeyringParcel(keyList, keyserver, false, forceReinsert);
} }
public static ImportKeyringParcel createWithSkipSave(List<ParcelableKeyRing> keyList, public static ImportKeyringParcel createWithSkipSave(List<ParcelableKeyRing> keyList,
HkpKeyserverAddress keyserver) { HkpKeyserverAddress keyserver) {
return new AutoValue_ImportKeyringParcel(keyList, keyserver, true); return new AutoValue_ImportKeyringParcel(keyList, keyserver, true, false);
} }
public static ImportKeyringParcel createImportKeyringParcel(ParcelableKeyRing key) { public static ImportKeyringParcel createImportKeyringParcel(ParcelableKeyRing key) {
return new AutoValue_ImportKeyringParcel(Collections.singletonList(key), null, false); return new AutoValue_ImportKeyringParcel(Collections.singletonList(key), null, false, false);
} }
public static ImportKeyringParcel createFromBytes(byte[] keyData) { public static ImportKeyringParcel createFromBytes(byte[] keyData) {
ParcelableKeyRing keyRing = ParcelableKeyRing.createFromEncodedBytes(keyData); ParcelableKeyRing keyRing = ParcelableKeyRing.createFromEncodedBytes(keyData);
return new AutoValue_ImportKeyringParcel(Collections.singletonList(keyRing), null, false); return new AutoValue_ImportKeyringParcel(Collections.singletonList(keyRing), null, false, false);
} }
public static ImportKeyringParcel createFromFileCacheWithSkipSave() { public static ImportKeyringParcel createFromFileCacheWithSkipSave() {
return new AutoValue_ImportKeyringParcel(null, null, true); return new AutoValue_ImportKeyringParcel(null, null, true, false);
} }
public static ImportKeyringParcel createFromFileCache() { public static ImportKeyringParcel createFromFileCache() {
return new AutoValue_ImportKeyringParcel(null, null, false); return new AutoValue_ImportKeyringParcel(null, null, false, false);
} }
} }